From 8e6c481ee9285a4ecce53864c042a898859b87c7 Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Tue, 19 May 2020 08:42:44 -0700 Subject: [PATCH 01/28] Remove duplicated entries (#1709) Github automatically parses the issue templates and adds them to the config file, so they don't need to be included here. --- .github/ISSUE_TEMPLATE/config.yml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index 74ffdedfb..ae66e0858 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -1,11 +1,5 @@ blank_issues_enabled: false contact_links: - - name: Bug Report - url: https://github.com/trailofbits/manticore/issues/new?labels=bug&template=bug_report.md - about: Report a bug in Manticore - - name: Feature Request - url: https://github.com/trailofbits/manticore/issues/new?labels=idea&template=feature_request.md - about: Request a new feature in Manticore - name: Ask a Question url: https://github.com/trailofbits/manticore/discussions/new about: Ask for help or clarification from the developers From c2b847a460cfcada1e250ffcc4826e470bf102ea Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 19 May 2020 14:05:47 -0300 Subject: [PATCH 02/28] Add a warning when selected no methods for inclusion (#1707) * Add a warning when selected no methods for inclusion * CC --- manticore/ethereum/plugins.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/manticore/ethereum/plugins.py b/manticore/ethereum/plugins.py index acabd1a77..cabe45fcf 100644 --- a/manticore/ethereum/plugins.py +++ b/manticore/ethereum/plugins.py @@ -2,10 +2,12 @@ from functools import reduce import re +import logging from ..core.plugin import Plugin from ..core.smtlib import Operators, to_constant import pyevmasm as EVMAsm +logger = logging.getLogger(__name__) class FilterFunctions(Plugin): @@ -78,8 +80,10 @@ def will_open_transaction_callback(self, state, tx): selected_functions.append(md.fallback_function_selector) if self._include: + if not selected_functions: + logger.warning("No functions selected, adding False to path constraint.") # constrain the input so it can take only the interesting values - constraint = reduce(Operators.OR, (tx.data[:4] == x for x in selected_functions)) + constraint = reduce(Operators.OR, (tx.data[:4] == x for x in selected_functions), False) state.constrain(constraint) else: # Avoid all not selected hashes From c39f870f596e98da56a82265f10e3e528418cada Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 19 May 2020 18:56:53 -0300 Subject: [PATCH 03/28] Fix plugin enable/disable magic (#1708) * FIx enable/disable magic * CC * Test enable/disable * Remove duplicated code --- manticore/core/manticore.py | 2 -- manticore/core/plugin.py | 49 ++++++++++++++++------------------ manticore/ethereum/plugins.py | 5 ++-- tests/ethereum/test_general.py | 38 ++++++++++++++++++++++++++ 4 files changed, 64 insertions(+), 30 deletions(-) diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index e73dab405..f7e7cf771 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -147,7 +147,6 @@ def sync(func: Callable) -> Callable: # type: ignore def newFunction(self, *args, **kw): with self._lock: return func(self, *args, **kw) - return newFunction def at_running(func: Callable) -> Callable: # type: ignore @@ -895,7 +894,6 @@ def locked_context(self, key=None, value_type=list): :param value_type: type of value associated with key :type value_type: list or dict or set """ - with self._lock: if key is None: # If no key is provided we yield the raw shared context under a lock diff --git a/manticore/core/plugin.py b/manticore/core/plugin.py index 46771c6b3..2ed79c218 100644 --- a/manticore/core/plugin.py +++ b/manticore/core/plugin.py @@ -10,20 +10,32 @@ logger = logging.getLogger(__name__) -class Plugin: +class DecorateAllMeta(type): + @staticmethod + def _if_enabled(f): + """ decorator used to guard callbacks """ + @wraps(f) + def g(self, *args, **kwargs): + if self.is_enabled(): + return f(self, *args, **kwargs) + return g + + def __new__(cls, name, bases, local): + for attr in local: + value = local[attr] + if attr.endswith("_callback") and callable(value): + local[attr] = cls._if_enabled(value) + return type.__new__(cls, name, bases, local) + + +class Plugin(metaclass=DecorateAllMeta): + __slots__ = ("manticore", "_enabled_key", "_plugin_context_name") def __init__(self): self.manticore = None - self._enabled_key = f"{str(type(self))}_enabled_{hash(self)}" - self._plugin_context_name = f"{str(type(self))}_context_{hash(self)}" - self.__decorate_callbacks() - - def __decorate_callbacks(self): - for attr in self.__dict__: - if attr.endswith('_callback'): - method = getattr(self, attr) - if callable(method): - setattr(self, attr, self._if_enabled(method)) + classname = str(type(self)).split("'")[1] + self._enabled_key = f"{classname}_enabled_{hex(hash(self))}" + self._plugin_context_name = f"{classname}_context_{hex(hash(self))}" def enable(self): """ Enable all callbacks """ @@ -40,15 +52,6 @@ def is_enabled(self): with self.manticore.locked_context() as context: return context.get(self._enabled_key, True) - @staticmethod - def _if_enabled(f): - """ decorator used to guard callbacks """ - @wraps(f) - def g(self, *args, **kwargs): - if self.is_enabled(): - return f(self, *args, **kwargs) - return g - @property def name(self): return str(self.__class__) @@ -148,20 +151,14 @@ def will_read_memory_callback(self, state, where, size): if self.current_pc == where: return - # print(f'will_read_memory {where:x} {size!r}, current_pc {self.current_pc:x}') - def did_read_memory_callback(self, state, where, value, size): if self.current_pc == where: return - # print(f'did_read_memory {where:x} {value!r} {size!r}, current_pc {self.current_pc:x}') - def will_write_memory_callback(self, state, where, value, size): if self.current_pc == where: return - # print(f'will_write_memory {where:x} {value!r} {size!r}, current_pc {self.current_pc:x}') - def did_write_memory_callback(self, state, where, value, size): if self.current_pc == where: raise Exception diff --git a/manticore/ethereum/plugins.py b/manticore/ethereum/plugins.py index cabe45fcf..fbcfc73a0 100644 --- a/manticore/ethereum/plugins.py +++ b/manticore/ethereum/plugins.py @@ -87,10 +87,11 @@ def will_open_transaction_callback(self, state, tx): state.constrain(constraint) else: # Avoid all not selected hashes + constraint = True for func_hsh in md.function_selectors: if func_hsh in selected_functions: - constraint = tx.data[:4] != func_hsh - state.constrain(constraint) + constraint = Operators.AND(tx.data[:4] != func_hsh, constraint) + state.constrain(constraint) class LoopDepthLimiter(Plugin): diff --git a/tests/ethereum/test_general.py b/tests/ethereum/test_general.py index ae04a9908..d0903cb79 100644 --- a/tests/ethereum/test_general.py +++ b/tests/ethereum/test_general.py @@ -1307,6 +1307,44 @@ def test_preconstraints(self): self.assertListEqual(sorted(results), ["STOP"] * 2 + ["TXERROR"]) + def test_plugins_enable(self): + #test enable/disable plugin and sync vs contextmanager + source_code = """ + contract C { + constructor() public payable {} + function f1(uint a) public payable {} + } + """ + class examplePlugin(Plugin): + def will_evm_execute_instruction_callback(self, state, i, *args, **kwargs): + with self.locked_context() as ctx: + if 'xcount' in ctx: + ctx['xcount'] = ctx['xcount'] + 1 + else: + ctx['xcount'] = 1 + + aplug = examplePlugin() + + m: ManticoreEVM = ManticoreEVM() + m.register_plugin(aplug) + + creator_account = m.create_account(balance=10000000000) + contract_account = m.solidity_create_contract(source_code, owner=creator_account, balance=0) + self.assertEqual( aplug.context.get('xcount',0), 10) #22 if revert? + + data = m.make_symbolic_buffer(320) + value = m.make_symbolic_value() + m.transaction(caller=creator_account, address=contract_account, data=data, value=value) + with aplug.locked_context() as ctx: + self.assertEqual(ctx.get('xcount',0), 63) + aplug.disable() + m.transaction(caller=creator_account, address=contract_account, data=data, value=value) + self.assertEqual( aplug.context.get('xcount',0), 63) + aplug.enable() + m.transaction(caller=creator_account, address=contract_account, data=data, value=value) + self.assertEqual( aplug.context.get('xcount',0), 112) + + class EthHelpersTest(unittest.TestCase): def setUp(self): self.bv = BitVec(256) From 2c90ee07c9e691304db97f573bff61ee220ffbb6 Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Tue, 19 May 2020 14:58:31 -0700 Subject: [PATCH 04/28] Use CoverageRC, Make CodeCov Less Aggressive (#1705) * Experimental coverage changes Tells coverage.py to record coverage for individual test cases, and makes CodeCov tolerate a small drop in overall coverage percentage to account for nondeterministic gas tests. * Use workspace * Remove explicit concurrency type declaration Appears to break use of subprocess in integration tests * Eliminate dynamic context * Make all CI respect rcfile * Use environment variable --- .github/workflows/ci.yml | 5 ++++- codecov.yml | 4 ++++ setup.cfg | 2 -- 3 files changed, 8 insertions(+), 3 deletions(-) delete mode 100644 setup.cfg diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3c5b2d3c9..44dd0f781 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -59,6 +59,7 @@ jobs: run: | # Launches all examples; this assumes PWD is examples/script launch_examples() { + COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc # concolic assumes presence of ../linux/simpleassert echo "Running concolic.py..." HW=../linux/helloworld @@ -150,6 +151,7 @@ jobs: } run_truffle_tests(){ + COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc mkdir truffle_tests cd truffle_tests truffle unbox metacoin @@ -169,8 +171,9 @@ jobs: run_tests_from_dir() { DIR=$1 + COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc echo "Running only the tests from 'tests/$DIR' directory" - pytest --durations=100 --cov=manticore -n auto "tests/$DIR" + pytest --durations=100 --cov=manticore --cov-config=$GITHUB_WORKSPACE/.coveragerc -n auto "tests/$DIR" coverage xml } diff --git a/codecov.yml b/codecov.yml index 9cd6e9730..bb6dccece 100644 --- a/codecov.yml +++ b/codecov.yml @@ -6,3 +6,7 @@ codecov: # If we add or remove any, we need to change this number. after_n_builds: 9 wait_for_ci: yes + status: + project: + default: + threshold: 0.2% diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index b5263f3b8..000000000 --- a/setup.cfg +++ /dev/null @@ -1,2 +0,0 @@ -[nosetests] -match=(?:^|[\b_\./-])([Tt]es|[Ee]th) From 6747143eca0de962c6fcca0c41bd5aff944b479f Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Thu, 28 May 2020 12:54:31 -0700 Subject: [PATCH 05/28] Fix Black (#1718) * Use merge SHA instead of head Github Actions doesn't update the head variable despite the checkout action merging the active branch into `master`, so the commit range specified was invalid * Start from common ancestor * Omit explicit SHA * Lint HEAD instead of merge * Manually fetch base SHA * Print the names of files to be diffed * Update ci.yml * Modify a Python file * Blacken everything that was missing The modified files got missed due to black not properly running on our CI --- .github/workflows/ci.yml | 6 ++++-- manticore/core/manticore.py | 1 + manticore/core/plugin.py | 2 ++ manticore/core/smtlib/constraints.py | 4 +++- manticore/ethereum/plugins.py | 5 ++++- scripts/pyfile_exists.py | 1 + tests/ethereum/test_general.py | 21 +++++++++++---------- 7 files changed, 26 insertions(+), 14 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 44dd0f781..34075d794 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,11 +23,13 @@ jobs: if: github.event_name == 'pull_request' env: BASE_SHA: ${{ github.event.pull_request.base.sha }} - HEAD_SHA: ${{ github.event.pull_request.head.sha }} run: | pip install -e .[lint] black --version - git diff --name-only $BASE_SHA..$HEAD_SHA | python scripts/pyfile_exists.py | xargs black --diff --check + git fetch --depth=1 origin $BASE_SHA + echo "Files Changed:" + git diff --name-only $BASE_SHA... | tee .diff_names.txt + cat .diff_names.txt | python scripts/pyfile_exists.py | xargs black --diff --check mypy --version mypy tests: diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index f7e7cf771..92074d57e 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -147,6 +147,7 @@ def sync(func: Callable) -> Callable: # type: ignore def newFunction(self, *args, **kw): with self._lock: return func(self, *args, **kw) + return newFunction def at_running(func: Callable) -> Callable: # type: ignore diff --git a/manticore/core/plugin.py b/manticore/core/plugin.py index 2ed79c218..6d1a1c4b2 100644 --- a/manticore/core/plugin.py +++ b/manticore/core/plugin.py @@ -14,10 +14,12 @@ class DecorateAllMeta(type): @staticmethod def _if_enabled(f): """ decorator used to guard callbacks """ + @wraps(f) def g(self, *args, **kwargs): if self.is_enabled(): return f(self, *args, **kwargs) + return g def __new__(cls, name, bases, local): diff --git a/manticore/core/smtlib/constraints.py b/manticore/core/smtlib/constraints.py index 36aff2f5f..df8312468 100644 --- a/manticore/core/smtlib/constraints.py +++ b/manticore/core/smtlib/constraints.py @@ -24,7 +24,9 @@ consts = config.get_group("smt") consts.add( - "related_constraints", default=False, description="Try slicing the current path constraint to contain only related items" + "related_constraints", + default=False, + description="Try slicing the current path constraint to contain only related items", ) diff --git a/manticore/ethereum/plugins.py b/manticore/ethereum/plugins.py index fbcfc73a0..15996ad24 100644 --- a/manticore/ethereum/plugins.py +++ b/manticore/ethereum/plugins.py @@ -7,6 +7,7 @@ from ..core.plugin import Plugin from ..core.smtlib import Operators, to_constant import pyevmasm as EVMAsm + logger = logging.getLogger(__name__) @@ -83,7 +84,9 @@ def will_open_transaction_callback(self, state, tx): if not selected_functions: logger.warning("No functions selected, adding False to path constraint.") # constrain the input so it can take only the interesting values - constraint = reduce(Operators.OR, (tx.data[:4] == x for x in selected_functions), False) + constraint = reduce( + Operators.OR, (tx.data[:4] == x for x in selected_functions), False + ) state.constrain(constraint) else: # Avoid all not selected hashes diff --git a/scripts/pyfile_exists.py b/scripts/pyfile_exists.py index 795f6bd6b..c6439ca6c 100644 --- a/scripts/pyfile_exists.py +++ b/scripts/pyfile_exists.py @@ -3,6 +3,7 @@ import os import sys +# Checks whether files listed via stdin actually exist for f in sys.stdin.readlines(): line = f.strip() if line.endswith(".py") and os.path.exists(line): diff --git a/tests/ethereum/test_general.py b/tests/ethereum/test_general.py index d0903cb79..f10271b4f 100644 --- a/tests/ethereum/test_general.py +++ b/tests/ethereum/test_general.py @@ -1306,22 +1306,22 @@ def test_preconstraints(self): # The TXERROR indicates a state where the sent value is greater than the senders budget. self.assertListEqual(sorted(results), ["STOP"] * 2 + ["TXERROR"]) - def test_plugins_enable(self): - #test enable/disable plugin and sync vs contextmanager + # test enable/disable plugin and sync vs contextmanager source_code = """ contract C { constructor() public payable {} function f1(uint a) public payable {} } """ + class examplePlugin(Plugin): def will_evm_execute_instruction_callback(self, state, i, *args, **kwargs): with self.locked_context() as ctx: - if 'xcount' in ctx: - ctx['xcount'] = ctx['xcount'] + 1 + if "xcount" in ctx: + ctx["xcount"] = ctx["xcount"] + 1 else: - ctx['xcount'] = 1 + ctx["xcount"] = 1 aplug = examplePlugin() @@ -1330,19 +1330,19 @@ def will_evm_execute_instruction_callback(self, state, i, *args, **kwargs): creator_account = m.create_account(balance=10000000000) contract_account = m.solidity_create_contract(source_code, owner=creator_account, balance=0) - self.assertEqual( aplug.context.get('xcount',0), 10) #22 if revert? + self.assertEqual(aplug.context.get("xcount", 0), 10) # 22 if revert? data = m.make_symbolic_buffer(320) value = m.make_symbolic_value() m.transaction(caller=creator_account, address=contract_account, data=data, value=value) - with aplug.locked_context() as ctx: - self.assertEqual(ctx.get('xcount',0), 63) + with aplug.locked_context() as ctx: + self.assertEqual(ctx.get("xcount", 0), 63) aplug.disable() m.transaction(caller=creator_account, address=contract_account, data=data, value=value) - self.assertEqual( aplug.context.get('xcount',0), 63) + self.assertEqual(aplug.context.get("xcount", 0), 63) aplug.enable() m.transaction(caller=creator_account, address=contract_account, data=data, value=value) - self.assertEqual( aplug.context.get('xcount',0), 112) + self.assertEqual(aplug.context.get("xcount", 0), 112) class EthHelpersTest(unittest.TestCase): @@ -1742,6 +1742,7 @@ def test_selfdestruct(self): ) self.assertEqual(m.count_ready_states(), 1) + class EthPluginTests(unittest.TestCase): def test_FilterFunctions_fallback_function_matching(self): """ From 3650e577bd1a611edcdaf4418b2068b6d62cdd13 Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 2 Jun 2020 18:03:01 -0300 Subject: [PATCH 06/28] Snapshots & is_main (#1710) * Snapshots * CC * Allow snapshooting just from main() * A test * Test and fix is_main * CC * review * ismain vs is_running * is main to is main script * Remove unused member variable * Fix is main variable * Update manticore/core/manticore.py Co-authored-by: Eric Hennenfent * review * blkn * Betteer Exception handling * Lint and test Co-authored-by: Eric Hennenfent --- manticore/__init__.py | 9 +++- manticore/core/manticore.py | 69 +++++++++++++++++++++++++++- manticore/core/worker.py | 1 - manticore/utils/config.py | 13 +++++- tests/ethereum/test_general.py | 83 ++++++++++++++++++++++++++++++++++ 5 files changed, 171 insertions(+), 4 deletions(-) diff --git a/manticore/__init__.py b/manticore/__init__.py index 4cae29336..b40b1e2ff 100644 --- a/manticore/__init__.py +++ b/manticore/__init__.py @@ -8,5 +8,12 @@ from .utils.log import set_verbosity from .core.smtlib import issymbolic, istainted from .ethereum.manticore import ManticoreEVM +from .exceptions import ManticoreError -__all__ = [issymbolic.__name__, istainted.__name__, ManticoreEVM.__name__, set_verbosity.__name__] +__all__ = [ + issymbolic.__name__, + istainted.__name__, + ManticoreEVM.__name__, + set_verbosity.__name__, + ManticoreError.__name__, +] diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index 92074d57e..68b8bb4d2 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -1,3 +1,4 @@ +import os import itertools import logging import sys @@ -177,6 +178,19 @@ def newFunction(self, *args, **kw): return newFunction + def only_from_main_script(func: Callable) -> Callable: # type: ignore + """Allows the decorated method to run only from the main manticore script + """ + + @functools.wraps(func) + def newFunction(self, *args, **kw): + if not self.is_main() or self.is_running(): + logger.error("Calling from worker or forked process not allowed") + raise ManticoreError(f"{func.__name__} only allowed from main") + return func(self, *args, **kw) + + return newFunction + _published_events = { "run", "start_worker", @@ -357,7 +371,60 @@ def __init__(self, initial_state, workspace_url=None, outputspace_url=None, **kw # Workers will use manticore __dict__ So lets spawn them last self._workers = [self._worker_type(id=i, manticore=self) for i in range(consts.procs)] - self._is_main = True + self._snapshot = None + self._main_id = os.getpid(), threading.current_thread().ident + + def is_main(self): + """ True if called from the main process/script + Note: in "single" mode this is _most likely_ True """ + return self._main_id == (os.getpid(), threading.current_thread().ident) + + @sync + @only_from_main_script + def take_snapshot(self): + """ Copy/Duplicate/backup all ready states and save it in a snapshot. + If there is a snapshot already saved it will be overrwritten + """ + if self._snapshot is not None: + logger.info("Overwriting a snapshot of the ready states") + snapshot = [] + for state_id in self._ready_states: + state = self._load(state_id) + # Re-save the state in case the user changed its data + snapshot.append(self._save(state)) + self._snapshot = snapshot + + @sync + @only_from_main_script + def goto_snapshot(self): + """ REMOVE current ready states and replace them with the saved states + in a snapshot """ + if not self._snapshot: + raise ManticoreError("No snapshot to go to") + for state_id in tuple(self._ready_states): + self._ready_states.remove(state_id) + for state_id in self._snapshot: + self._ready_states.append(state_id) + self._snapshot = None + + @sync + @only_from_main_script + def clear_snapshot(self): + """ Remove any saved states """ + if self._snapshot: + for state_id in self._snapshot: + self._remove(state_id) + self._snapshot = None + + @sync + @at_not_running + def clear_terminated_states(self): + """ Simply remove all states from terminated list """ + terminated_states_ids = tuple(self._terminated_states) + for state_id in terminated_states_ids: + self._terminated_states.remove(state_id) + self._remove(state_id) + assert self.count_terminated_states() == 0 def __str__(self): return f"<{str(type(self))[8:-2]}| Alive States: {self.count_ready_states()}; Running States: {self.count_busy_states()} Terminated States: {self.count_terminated_states()} Killed States: {self.count_killed_states()} Started: {self._running.value} Killed: {self._killed.value}>" diff --git a/manticore/core/worker.py b/manticore/core/worker.py index f2e2ac0e5..2b6fe5e9b 100644 --- a/manticore/core/worker.py +++ b/manticore/core/worker.py @@ -67,7 +67,6 @@ def run(self, *args): ) m = self.manticore - m._is_main = False # This will mark our copy of manticore current_state = None m._publish("will_start_worker", self.id) diff --git a/manticore/utils/config.py b/manticore/utils/config.py index a18f5e156..f6841ac82 100644 --- a/manticore/utils/config.py +++ b/manticore/utils/config.py @@ -31,7 +31,7 @@ class _Var: def __init__(self, name: str = "", default=None, description: str = None, defined: bool = True): self.name = name self.description = description - self.value = default + self._value = default self.default = default self.defined = defined @@ -39,6 +39,17 @@ def __init__(self, name: str = "", default=None, description: str = None, define def was_set(self) -> bool: return self.value is not self.default + @property + def value(self): + return self._value + + @value.setter + def value(self, value): + # Forgiveness/Enums support from_string + if isinstance(self.default, Enum) and isinstance(value, str): + value = self.default.from_string(value) + self._value = value + class _Group: """ diff --git a/tests/ethereum/test_general.py b/tests/ethereum/test_general.py index f10271b4f..302703466 100644 --- a/tests/ethereum/test_general.py +++ b/tests/ethereum/test_general.py @@ -10,6 +10,7 @@ import struct import tempfile +from manticore import ManticoreError from manticore.core.plugin import Plugin from manticore.core.smtlib import ConstraintSet, operators from manticore.core.smtlib import Z3Solver @@ -1794,6 +1795,88 @@ def test_FilterFunctions_fallback_function_matching(self): ABI.deserialize("uint", to_constant(m.world.transactions[-1].return_data)), 456 ) + def test_checkpoint(self): + # test enable/disable plugin and sync vs contextmanager + source_code = """ + contract C { + constructor() public payable {} + function f1(uint a) public payable {} + function f2(uint a) public payable {} + } + """ + + m: ManticoreEVM = ManticoreEVM() + + creator_account = m.create_account(balance=10000000000) + contract_account = m.solidity_create_contract(source_code, owner=creator_account, balance=0) + + # Can not go to unexistant snapshot + self.assertRaises(ManticoreError, m.goto_snapshot) + self.assertEqual(m.count_ready_states(), 1) + # take the snap + m.take_snapshot() + self.assertEqual(m.count_ready_states(), 1) + + data = m.make_symbolic_buffer(320) + value = m.make_symbolic_value() + m.transaction(caller=creator_account, address=contract_account, data=data, value=value) + self.assertEqual(m.count_ready_states(), 2) + self.assertEqual(m.count_terminated_states(), 2) + m.goto_snapshot() # return to have only 1 ready state. (The terminated states remain) + + self.assertEqual(m.count_ready_states(), 1) + self.assertEqual(m.count_terminated_states(), 2) + + data = m.make_symbolic_buffer(320) + value = m.make_symbolic_value() + m.transaction(caller=creator_account, address=contract_account, data=data, value=value) + self.assertEqual(m.count_ready_states(), 2) + + m.clear_snapshot() + # Can not go to unexistant snapshot + self.assertRaises(Exception, m.goto_snapshot) + self.assertEqual(m.count_terminated_states(), 4) + m.clear_terminated_states() + self.assertEqual(m.count_terminated_states(), 0) + + m.clear_snapshot() # We can double clear it + + def test_is_main(self): + # test enable/disable plugin and sync vs contextmanager + source_code = """ + contract C { + constructor() public payable {} + function f1(uint a) public payable {} + function f2(uint a) public payable {} + } + """ + + class X(Plugin): + def will_evm_execute_instruction_callback(self, state, instruction, args): + is_main = self.manticore.is_main() + is_running = self.manticore.is_running() + with self.locked_context() as ctx: + ctx["is_main"] = ctx.get("is_main", False) or (is_main and not is_running) + + from manticore.utils import config + + consts = config.get_group("core") + for ty in ("multiprocessing", "threading", "single"): + consts.mprocessing = ty + m: ManticoreEVM = ManticoreEVM() + x = X() + m.register_plugin(x) + self.assertTrue(m.is_main()) + + creator_account = m.create_account(balance=10000000000) + contract_account = m.solidity_create_contract( + source_code, owner=creator_account, balance=0 + ) + + self.assertTrue(m.is_main() and not m.is_running()) + # From the plugin callback is never main + self.assertFalse(x.context.get("is_main", False)) + if __name__ == "__main__": unittest.main() From 4495b6f03e0e36ced3fcb9a1e782b10759ddef90 Mon Sep 17 00:00:00 2001 From: feliam Date: Thu, 4 Jun 2020 19:27:59 -0300 Subject: [PATCH 07/28] VMTests tests for istanbul (#1676) * New upstream auto-VMTests tests for istanbul * Removed redundant tests * bugfix * Reset CI * Debug CI 1 * debug CI * wakey wakey GitHub Actions * Poke GH * Fix detector * New CI weaky weaky * Change default smtlib max memory usage weaky weaky * ci weaky waky * ci weaky waky * CI waky weaky * Fix test_general weaky weaky * Fix ethtests. weaky waky * Unittest driven bugfixes. weaky waky * Avoid check-sat in the middle of a solving. weaky wakey * Fix config. weaky wakey * Reduce queries in IO detector * CC * CC * fix nativve tests * CC and solver defaults * merge. weaky waky * Fixing tests * Remove debug print * Fix in DetectUninitializedMemory * Change truffle test state count * CC * Better forking on failed transactions * CC * Fix truffle tst state count * Improve z3 speed * Fix truffle test state count * Change default gas concretization in CALL * Better logging at fork * Insane commit to fix several bugfixes and refator stuff * black * Fix selfdestruct test * Fix some unittests * Default to bytes fo constant calldata * Fix tests * Better doc * https://github.com/trailofbits/manticore/pull/1676/files#r426927762 * https://github.com/trailofbits/manticore/pull/1676/files#r426946198 * Leave native alone and fix pyevmasm dep * Update manticore/platforms/evm.py Co-authored-by: Eric Hennenfent * Update manticore/platforms/evm.py Co-authored-by: Eric Hennenfent * isSeven * OPTI/PESI * Truffle optimistic * truffle fix * Truffle state count * CC * Fix tests PESI/OPTI * Update manticore/core/state.py Co-authored-by: Samuel E. Moelius <35515885+smoelius@users.noreply.github.com> * Better policy naming * Update manticore/platforms/evm.py Co-authored-by: Samuel E. Moelius <35515885+smoelius@users.noreply.github.com> * Update manticore/ethereum/manticore.py Co-authored-by: Samuel E. Moelius <35515885+smoelius@users.noreply.github.com> * Update manticore/platforms/evm.py Co-authored-by: Samuel E. Moelius <35515885+smoelius@users.noreply.github.com> * PESi PESSI * blkn * weaky * wakey wakey * blkn * unreachable * Fix state count in checkpoint test (merge) * remove unused exception var Co-authored-by: Eric Hennenfent Co-authored-by: Samuel E. Moelius <35515885+smoelius@users.noreply.github.com> --- .github/workflows/ci.yml | 10 +- manticore/__init__.py | 1 + manticore/core/smtlib/constraints.py | 2 +- manticore/core/smtlib/expression.py | 40 +- manticore/core/smtlib/solver.py | 20 +- manticore/core/smtlib/visitors.py | 16 +- manticore/core/state.py | 16 +- manticore/ethereum/account.py | 7 +- manticore/ethereum/detectors.py | 32 +- manticore/ethereum/manticore.py | 87 +- manticore/ethereum/plugins.py | 3 +- manticore/native/memory.py | 4 +- manticore/platforms/evm.py | 1002 +- manticore/utils/config.py | 9 +- setup.py | 5 +- tests/auto_generators/make_VMTests.py | 675 +- tests/ethereum/EVM/__init__.py | 0 tests/ethereum/EVM/test_EVMADD.py | 2007 -- tests/ethereum/EVM/test_EVMADDMOD.py | 17766 ---------------- tests/ethereum/EVM/test_EVMADDRESS.py | 60 - tests/ethereum/EVM/test_EVMAND.py | 1929 -- tests/ethereum/EVM/test_EVMBALANCE.py | 291 - tests/ethereum/EVM/test_EVMBYTE.py | 1902 -- tests/ethereum/EVM/test_EVMCALLCODE.py | 333 - tests/ethereum/EVM/test_EVMCALLDATALOAD.py | 247 - tests/ethereum/EVM/test_EVMCALLDATASIZE.py | 60 - tests/ethereum/EVM/test_EVMCALLER.py | 60 - tests/ethereum/EVM/test_EVMCALLVALUE.py | 60 - tests/ethereum/EVM/test_EVMCODESIZE.py | 60 - tests/ethereum/EVM/test_EVMCOINBASE.py | 60 - tests/ethereum/EVM/test_EVMDIFFICULTY.py | 60 - tests/ethereum/EVM/test_EVMDIV.py | 1938 -- tests/ethereum/EVM/test_EVMDUP.py | 411 - tests/ethereum/EVM/test_EVMEQ.py | 1902 -- tests/ethereum/EVM/test_EVMEXP.py | 1944 -- tests/ethereum/EVM/test_EVMEXTCODESIZE.py | 291 - tests/ethereum/EVM/test_EVMGAS.py | 60 - tests/ethereum/EVM/test_EVMGASLIMIT.py | 60 - tests/ethereum/EVM/test_EVMGASPRICE.py | 58 - tests/ethereum/EVM/test_EVMGETPC.py | 60 - tests/ethereum/EVM/test_EVMGT.py | 1902 -- tests/ethereum/EVM/test_EVMINVALID.py | 59 - tests/ethereum/EVM/test_EVMISZERO.py | 237 - tests/ethereum/EVM/test_EVMJUMP.py | 244 - tests/ethereum/EVM/test_EVMJUMPDEST.py | 60 - tests/ethereum/EVM/test_EVMLT.py | 1902 -- tests/ethereum/EVM/test_EVMMOD.py | 1917 -- tests/ethereum/EVM/test_EVMMSIZE.py | 61 - tests/ethereum/EVM/test_EVMMSTORE8.py | 1885 -- tests/ethereum/EVM/test_EVMMUL.py | 2004 -- tests/ethereum/EVM/test_EVMMULMOD.py | 17679 --------------- tests/ethereum/EVM/test_EVMNOT.py | 261 - tests/ethereum/EVM/test_EVMOR.py | 2037 -- tests/ethereum/EVM/test_EVMORIGIN.py | 56 - tests/ethereum/EVM/test_EVMPOP.py | 237 - tests/ethereum/EVM/test_EVMPUSH.py | 711 - tests/ethereum/EVM/test_EVMREVERT.py | 288 - tests/ethereum/EVM/test_EVMSDIV.py | 1950 -- tests/ethereum/EVM/test_EVMSELFDESTRUCT.py | 440 - tests/ethereum/EVM/test_EVMSGT.py | 1902 -- tests/ethereum/EVM/test_EVMSHA3.py | 2380 --- tests/ethereum/EVM/test_EVMSHIFT.py | 885 - tests/ethereum/EVM/test_EVMSIGNEXTEND.py | 1974 -- tests/ethereum/EVM/test_EVMSLOAD.py | 293 - tests/ethereum/EVM/test_EVMSLT.py | 1902 -- tests/ethereum/EVM/test_EVMSMOD.py | 1926 -- tests/ethereum/EVM/test_EVMSSTORE.py | 2452 --- tests/ethereum/EVM/test_EVMSUB.py | 2055 -- tests/ethereum/EVM/test_EVMXOR.py | 2028 -- tests/ethereum/test_detectors.py | 2 + tests/ethereum/test_general.py | 121 +- tests/ethereum/test_regressions.py | 4 +- tests/ethereum/test_sha3.py | 52 +- .../test_consensys_benchmark.py | 9 + .../ethereum_vm/VMTests_concrete/__init__.py | 1 - .../ethereum_vm/VMTests_symbolic/__init__.py | 1 - tests/native/test_memory.py | 19 +- tests/other/test_smtlibv2.py | 7 + 78 files changed, 1247 insertions(+), 84244 deletions(-) delete mode 100644 tests/ethereum/EVM/__init__.py delete mode 100644 tests/ethereum/EVM/test_EVMADD.py delete mode 100644 tests/ethereum/EVM/test_EVMADDMOD.py delete mode 100644 tests/ethereum/EVM/test_EVMADDRESS.py delete mode 100644 tests/ethereum/EVM/test_EVMAND.py delete mode 100644 tests/ethereum/EVM/test_EVMBALANCE.py delete mode 100644 tests/ethereum/EVM/test_EVMBYTE.py delete mode 100644 tests/ethereum/EVM/test_EVMCALLCODE.py delete mode 100644 tests/ethereum/EVM/test_EVMCALLDATALOAD.py delete mode 100644 tests/ethereum/EVM/test_EVMCALLDATASIZE.py delete mode 100644 tests/ethereum/EVM/test_EVMCALLER.py delete mode 100644 tests/ethereum/EVM/test_EVMCALLVALUE.py delete mode 100644 tests/ethereum/EVM/test_EVMCODESIZE.py delete mode 100644 tests/ethereum/EVM/test_EVMCOINBASE.py delete mode 100644 tests/ethereum/EVM/test_EVMDIFFICULTY.py delete mode 100644 tests/ethereum/EVM/test_EVMDIV.py delete mode 100644 tests/ethereum/EVM/test_EVMDUP.py delete mode 100644 tests/ethereum/EVM/test_EVMEQ.py delete mode 100644 tests/ethereum/EVM/test_EVMEXP.py delete mode 100644 tests/ethereum/EVM/test_EVMEXTCODESIZE.py delete mode 100644 tests/ethereum/EVM/test_EVMGAS.py delete mode 100644 tests/ethereum/EVM/test_EVMGASLIMIT.py delete mode 100644 tests/ethereum/EVM/test_EVMGASPRICE.py delete mode 100644 tests/ethereum/EVM/test_EVMGETPC.py delete mode 100644 tests/ethereum/EVM/test_EVMGT.py delete mode 100644 tests/ethereum/EVM/test_EVMINVALID.py delete mode 100644 tests/ethereum/EVM/test_EVMISZERO.py delete mode 100644 tests/ethereum/EVM/test_EVMJUMP.py delete mode 100644 tests/ethereum/EVM/test_EVMJUMPDEST.py delete mode 100644 tests/ethereum/EVM/test_EVMLT.py delete mode 100644 tests/ethereum/EVM/test_EVMMOD.py delete mode 100644 tests/ethereum/EVM/test_EVMMSIZE.py delete mode 100644 tests/ethereum/EVM/test_EVMMSTORE8.py delete mode 100644 tests/ethereum/EVM/test_EVMMUL.py delete mode 100644 tests/ethereum/EVM/test_EVMMULMOD.py delete mode 100644 tests/ethereum/EVM/test_EVMNOT.py delete mode 100644 tests/ethereum/EVM/test_EVMOR.py delete mode 100644 tests/ethereum/EVM/test_EVMORIGIN.py delete mode 100644 tests/ethereum/EVM/test_EVMPOP.py delete mode 100644 tests/ethereum/EVM/test_EVMPUSH.py delete mode 100644 tests/ethereum/EVM/test_EVMREVERT.py delete mode 100644 tests/ethereum/EVM/test_EVMSDIV.py delete mode 100644 tests/ethereum/EVM/test_EVMSELFDESTRUCT.py delete mode 100644 tests/ethereum/EVM/test_EVMSGT.py delete mode 100644 tests/ethereum/EVM/test_EVMSHA3.py delete mode 100644 tests/ethereum/EVM/test_EVMSHIFT.py delete mode 100644 tests/ethereum/EVM/test_EVMSIGNEXTEND.py delete mode 100644 tests/ethereum/EVM/test_EVMSLOAD.py delete mode 100644 tests/ethereum/EVM/test_EVMSLT.py delete mode 100644 tests/ethereum/EVM/test_EVMSMOD.py delete mode 100644 tests/ethereum/EVM/test_EVMSSTORE.py delete mode 100644 tests/ethereum/EVM/test_EVMSUB.py delete mode 100644 tests/ethereum/EVM/test_EVMXOR.py delete mode 100644 tests/ethereum_vm/VMTests_concrete/__init__.py delete mode 100644 tests/ethereum_vm/VMTests_symbolic/__init__.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 34075d794..f13c2e275 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -118,8 +118,8 @@ jobs: echo "Automaking VMTests" `pwd` cd ./tests/ && mkdir -p ethereum_vm/VMTests_concrete && mkdir -p ethereum_vm/VMTests_symbolic rm -Rf vmtests; git clone https://github.com/ethereum/tests --depth=1 vmtests - for i in ./vmtests/VMTests/*; do python ./auto_generators/make_VMTests.py $i; done - for i in ./vmtests/VMTests/*; do python ./auto_generators/make_VMTests.py $i --symbolic; done + for i in ./vmtests/BlockchainTests/ValidBlocks/VMTests/*/*json; do python ./auto_generators/make_VMTests.py -f istanbul -i $i -o ethereum_vm/VMTests_concrete; done + rm ethereum_vm/VMTests_concrete/test_loop*.py #too slow rm -rf ./vmtests touch ethereum_vm/.done fi @@ -157,11 +157,11 @@ jobs: mkdir truffle_tests cd truffle_tests truffle unbox metacoin - coverage run -m manticore . --contract MetaCoin --workspace output + coverage run -m manticore . --contract MetaCoin --workspace output --exclude-all --evm.oog ignore --evm.txfail optimistic # Truffle smoke test. We test if manticore is able to generate states # from a truffle project. - if [ "$(ls output/*tx -l | wc -l)" != "34" ]; then - echo "Truffle test failed" `ls output/*tx -l | wc -l` "!= 34" + if [ "$(ls output/*tx -l | wc -l)" != "26" ]; then + echo "Truffle test failed" `ls output/*tx -l | wc -l` "!= 26" return 1 fi echo "Truffle test succeded" diff --git a/manticore/__init__.py b/manticore/__init__.py index b40b1e2ff..753996dbb 100644 --- a/manticore/__init__.py +++ b/manticore/__init__.py @@ -8,6 +8,7 @@ from .utils.log import set_verbosity from .core.smtlib import issymbolic, istainted from .ethereum.manticore import ManticoreEVM +from .core.plugin import Plugin from .exceptions import ManticoreError __all__ = [ diff --git a/manticore/core/smtlib/constraints.py b/manticore/core/smtlib/constraints.py index df8312468..711e5e91a 100644 --- a/manticore/core/smtlib/constraints.py +++ b/manticore/core/smtlib/constraints.py @@ -148,7 +148,7 @@ def __get_related(self, related_to=None): break variables = get_variables(constraint) - if related_variables & variables: + if related_variables & variables or not (variables): remaining_constraints.remove(constraint) related_constraints.add(constraint) related_variables |= variables diff --git a/manticore/core/smtlib/expression.py b/manticore/core/smtlib/expression.py index d300d85e5..60ea896f6 100644 --- a/manticore/core/smtlib/expression.py +++ b/manticore/core/smtlib/expression.py @@ -159,6 +159,12 @@ def __rxor__(self, other): return BoolXor(self.cast(other), self) def __bool__(self): + # try to be forgiving. Allow user to use Bool in an IF sometimes + from .visitors import simplify + + x = simplify(self) + if isinstance(x, Constant): + return x.value raise NotImplementedError("__bool__ for Bool") @@ -479,7 +485,8 @@ class BitVecConstant(BitVec): __slots__ = ["_value"] def __init__(self, size: int, value: int, *args, **kwargs): - self._value = value + MASK = (1 << size) - 1 + self._value = value & MASK super().__init__(size, *args, **kwargs) def __bool__(self): @@ -798,6 +805,7 @@ def underlying_variable(self): return array def read_BE(self, address, size): + address = self.cast_index(address) bytes = [] for offset in range(size): bytes.append(self.get(address + offset, 0)) @@ -1072,6 +1080,7 @@ def store(self, index, value): self._concrete_cache = {} # potentially generate and update .written set + # if index is symbolic it may overwrite other previous indexes self.written.add(index) self._array = self._array.store(index, value) return self @@ -1150,11 +1159,21 @@ def is_known(self, index): is_known_index = BoolConstant(False) written = self.written - for known_index in written: - if isinstance(index, Constant) and isinstance(known_index, Constant): - if known_index.value == index.value: + if isinstance(index, Constant): + for i in written: + # check if the concrete index is explicitly in written + if isinstance(i, Constant) and index.value == i.value: return BoolConstant(True) + + # Build an expression to check if our concrete index could be the + # solution for anyof the used symbolic indexes + is_known_index = BoolOr(is_known_index.cast(index == i), is_known_index) + return is_known_index + + # The index is symbolic we need to compare it agains it all + for known_index in written: is_known_index = BoolOr(is_known_index.cast(index == known_index), is_known_index) + return is_known_index def get(self, index, default=None): @@ -1171,12 +1190,15 @@ def get(self, index, default=None): if isinstance(index, Constant) and index.value in self._concrete_cache: return self._concrete_cache[index.value] - value = self._array.select(index) - if default is None: - return value + if default is not None: + default = self.cast_value(default) + is_known = self.is_known(index) + if isinstance(is_known, Constant) and is_known.value == False: + return default + else: + return self._array.select(index) - is_known = self.is_known(index) - default = self.cast_value(default) + value = self._array.select(index) return BitVecITE(self._array.value_bits, is_known, value, default) diff --git a/manticore/core/smtlib/solver.py b/manticore/core/smtlib/solver.py index 708e6dcee..f389a186f 100644 --- a/manticore/core/smtlib/solver.py +++ b/manticore/core/smtlib/solver.py @@ -32,8 +32,8 @@ logger = logging.getLogger(__name__) consts = config.get_group("smt") -consts.add("timeout", default=240, description="Timeout, in seconds, for each Z3 invocation") -consts.add("memory", default=16384, description="Max memory for Z3 to use (in Megabytes)") +consts.add("timeout", default=120, description="Timeout, in seconds, for each Z3 invocation") +consts.add("memory", default=1024 * 8, description="Max memory for Z3 to use (in Megabytes)") consts.add( "maxsolutions", default=10000, @@ -333,7 +333,6 @@ def _recv(self) -> str: buf = "".join(bufl).strip() if "(error" in bufl[0]: raise SolverException(f"Error in smtlib: {bufl[0]}") - return buf def __readline_and_count(self) -> Tuple[str, int, int]: @@ -450,6 +449,10 @@ def get_all_values(self, constraints, expression, maxcnt=None, silent=False): expression = simplify(expression) if maxcnt is None: maxcnt = consts.maxsolutions + if isinstance(expression, Bool) and consts.maxsolutions > 1: + # We know there is max 2 solutions when Bool + maxcnt = 2 + silent = True with constraints as temp_cs: if isinstance(expression, Bool): @@ -470,12 +473,10 @@ def get_all_values(self, constraints, expression, maxcnt=None, silent=False): temp_cs.add(var == expression) self._reset(temp_cs.to_string(related_to=var)) result = [] - start = time.time() while self._is_sat(): value = self._getvalue(var) result.append(value) - self._assert(var != value) if len(result) >= maxcnt: if silent: @@ -487,8 +488,15 @@ def get_all_values(self, constraints, expression, maxcnt=None, silent=False): else: raise TooManySolutions(result) if time.time() - start > consts.timeout: + if silent: + logger.info("Timeout searching for all solutions") + return result raise SolverError("Timeout") - return result + # Sometimes adding a new contraint after a check-sat eats all the mem + temp_cs.add(var != value) + self._reset(temp_cs.to_string(related_to=var)) + # self._assert(var != value) + return list(result) def optimize(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10000): """ diff --git a/manticore/core/smtlib/visitors.py b/manticore/core/smtlib/visitors.py index be126fff4..cbb256e11 100644 --- a/manticore/core/smtlib/visitors.py +++ b/manticore/core/smtlib/visitors.py @@ -285,7 +285,7 @@ def __init__(self, **kw): BitVecAdd: operator.__add__, BitVecSub: operator.__sub__, BitVecMul: operator.__mul__, - BitVecDiv: operator.__truediv__, + BitVecDiv: operator.__floordiv__, BitVecShiftLeft: operator.__lshift__, BitVecShiftRight: operator.__rshift__, BitVecAnd: operator.__and__, @@ -325,12 +325,12 @@ def visit_BitVecSignExtend(self, expression, *operands): return operands[0] def visit_BitVecExtract(self, expression, *operands): - if all(isinstance(o, Constant) for o in expression.operands): - value = expression.operands[0].value + if all(isinstance(o, Constant) for o in operands): + value = operands[0].value begining = expression.begining end = expression.end value = value >> begining - mask = 2 ** (end - begining + 1) - 1 + mask = (1 << (end - begining)) - 1 value = value & mask return BitVecConstant(expression.size, value, taint=expression.taint) @@ -618,6 +618,8 @@ def visit_BitVecExtract(self, expression, *operands): new_operands.append(BitVecExtract(item, begining, item.size - begining)) size -= item.size - begining begining = 0 + elif isinstance(op, BitVecConstant): + return BitVecConstant(size, (op.value >> begining) & ~(1 << size)) if isinstance(op, (BitVecAnd, BitVecOr, BitVecXor)): bitoperand_a, bitoperand_b = op.operands @@ -767,7 +769,7 @@ def visit_Expression(self, expression, *operands): return expression -arithmetic_simplifier_cache = CacheDict(max_size=150000, flush_perc=25) +arithmetic_simplifier_cache = CacheDict(max_size=250000, flush_perc=25) @lru_cache(maxsize=128, typed=True) @@ -919,10 +921,6 @@ def _visit_operation(self, expression, *operands): visit_BoolOperation = _visit_operation visit_BitVecOperation = _visit_operation - @property - def results(self): - raise SmtlibError("NOOO") - @property def result(self): output = super().result diff --git a/manticore/core/state.py b/manticore/core/state.py index d5a8927de..abb5060e5 100644 --- a/manticore/core/state.py +++ b/manticore/core/state.py @@ -40,7 +40,7 @@ class Concretize(StateException): """ - _ValidPolicies = ["MIN", "MAX", "MINMAX", "ALL", "SAMPLED", "ONE"] + _ValidPolicies = ["MIN", "MAX", "MINMAX", "ALL", "SAMPLED", "ONE", "PESSIMISTIC", "OPTIMISTIC"] def __init__(self, message, expression, setstate=None, policy=None, **kwargs): if policy is None: @@ -296,6 +296,20 @@ def concretize(self, symbolic, policy, maxcount=7): ) elif policy == "ONE": vals = [self._solver.get_value(self._constraints, symbolic)] + elif policy == "OPTIMISTIC": + logger.info("Optimistic case when forking") + if self._solver.can_be_true(self._constraints, symbolic): + vals = (True,) + else: + # We assume the path constraint was feasible to begin with + vals = (False,) + elif policy == "PESSIMISTIC": + logger.info("Pessimistic case when forking") + if self._solver.can_be_true(self._constraints, symbolic == False): + vals = (False,) + else: + # We assume the path constraint was feasible to begin with + vals = (True,) else: assert policy == "ALL" vals = self._solver.get_all_values( diff --git a/manticore/ethereum/account.py b/manticore/ethereum/account.py index bde758d40..17be598bb 100644 --- a/manticore/ethereum/account.py +++ b/manticore/ethereum/account.py @@ -113,12 +113,7 @@ def __getattr__(self, name): if name in self.__hashes: def f( - *args, - signature: Optional[str] = None, - caller=None, - value=0, - gas=0xFFFFFFFFFFFF, - **kwargs, + *args, signature: Optional[str] = None, caller=None, value=0, gas=210000, **kwargs ): try: if signature: diff --git a/manticore/ethereum/detectors.py b/manticore/ethereum/detectors.py index 521525e28..b850ca79a 100644 --- a/manticore/ethereum/detectors.py +++ b/manticore/ethereum/detectors.py @@ -171,6 +171,7 @@ class DetectExternalCallAndLeak(Detector): CONFIDENCE = DetectorClassification.HIGH def will_evm_execute_instruction_callback(self, state, instruction, arguments): + if instruction.semantics == "CALL": dest_address = arguments[1] sent_value = arguments[2] @@ -203,7 +204,7 @@ def will_evm_execute_instruction_callback(self, state, instruction, arguments): ) else: if msg_sender == dest_address: - self.add_finding_here(state, f"Reachable {msg} to sender") + self.add_finding_here(state, f"Reachable {msg} to sender", True) class DetectInvalid(Detector): @@ -329,7 +330,7 @@ def did_close_transaction_callback(self, state, tx): # Check is the tx was successful if tx.result: # Check if gas was enough for a reentrancy attack - if tx.gas > 2300: + if state.can_be_true(Operators.UGE(tx.gas, 2300)): # Check if target address is attaker controlled if ( self._addresses is None @@ -525,6 +526,8 @@ def did_evm_execute_instruction_callback(self, state, instruction, arguments, re iou = self._unsigned_sub_overflow(state, *arguments) elif mnemonic == "SSTORE": # If an overflowded value is stored in the storage then it is a finding + # Todo: save this in a stack and only do the check if this does not + # revert/rollback where, what = arguments self._check_finding(state, what) elif mnemonic == "RETURN": @@ -537,18 +540,18 @@ def did_evm_execute_instruction_callback(self, state, instruction, arguments, re if mnemonic in ("SLT", "SGT", "SDIV", "SMOD"): result = taint_with(result, "SIGNED") - vm.change_last_result(result) - if state.can_be_true(ios): + if mnemonic in ("ADD", "SUB", "MUL"): id_val = self._save_current_location( state, "Signed integer overflow at %s instruction" % mnemonic, ios ) result = taint_with(result, "IOS_{:s}".format(id_val)) - vm.change_last_result(result) - if state.can_be_true(iou): + id_val = self._save_current_location( state, "Unsigned integer overflow at %s instruction" % mnemonic, iou ) result = taint_with(result, "IOU_{:s}".format(id_val)) + + if mnemonic in ("SLT", "SGT", "SDIV", "SMOD", "ADD", "SUB", "MUL"): vm.change_last_result(result) @@ -627,6 +630,11 @@ class DetectDelegatecall(Detector): IMPACT = DetectorClassification.HIGH CONFIDENCE = DetectorClassification.HIGH + def _to_constant(self, expression): + if isinstance(expression, Constant): + return expression.value + return expression + def will_evm_execute_instruction_callback(self, state, instruction, arguments): world = state.platform mnemonic = instruction.semantics @@ -643,6 +651,8 @@ def will_evm_execute_instruction_callback(self, state, instruction, arguments): if len(possible_addresses) > 1: self.add_finding_here(state, "Delegatecall to user controlled address") + in_offset = self._to_constant(in_offset) + in_size = self._to_constant(in_size) calldata = world.current_vm.read_buffer(in_offset, in_size) func_id = calldata[:4] if issymbolic(func_id): @@ -667,8 +677,8 @@ def did_evm_read_memory_callback(self, state, offset, value, size): current_contract = state.platform.current_vm.address for known_contract, known_offset in initialized_memory: if current_contract == known_contract: - for offset_i in range(offset, offset + size): - cbu = Operators.AND(cbu, offset_i != known_offset) + for offset_i in range(size): + cbu = Operators.AND(cbu, (offset + offset_i) != known_offset) if state.can_be_true(cbu): self.add_finding_here( state, @@ -680,9 +690,9 @@ def did_evm_write_memory_callback(self, state, offset, value, size): current_contract = state.platform.current_vm.address # concrete or symbolic write - for offset_i in range(offset, offset + size): + for offset_i in range(size): state.context.setdefault("{:s}.initialized_memory".format(self.name), set()).add( - (current_contract, offset) + (current_contract, offset + offset_i) ) @@ -809,7 +819,7 @@ def did_evm_execute_instruction_callback(self, state, instruction, arguments, re world = state.platform curr_tx = world.current_transaction - if curr_tx.sort != "CREATE": + if curr_tx.sort != "CREATE" and curr_tx.address in self.manticore.metadata: metadata = self.manticore.metadata[curr_tx.address] curr_func = metadata.get_func_signature(state.solve_one(curr_tx.data[:4])) diff --git a/manticore/ethereum/manticore.py b/manticore/ethereum/manticore.py index e5a2d9670..82656f07f 100644 --- a/manticore/ethereum/manticore.py +++ b/manticore/ethereum/manticore.py @@ -283,7 +283,7 @@ def _compile_through_crytic_compile(filename, contract_name, libraries, crytic_c if not contract_name: if len(crytic_compile.contracts_names_without_libraries) > 1: raise EthereumError( - f"Solidity file must contain exactly one contract or you must use a `--contract` parameter to specify one. Contracts found: {', '.join(crytic_compile.contracts_names)}" + f"Solidity file must contain exactly one contract or you must select one. Contracts found: {', '.join(crytic_compile.contracts_names)}" ) contract_name = list(crytic_compile.contracts_names_without_libraries)[0] @@ -390,18 +390,20 @@ def contract_accounts(self): def get_account(self, name): return self._accounts[name] - def __init__(self, workspace_url: str = None, policy: str = "random"): + def __init__(self, plugins=None, **kwargs): """ A Manticore EVM manager - :param workspace_url: workspace folder name - :param policy: scheduling priority + :param plugins: the plugins to register in this manticore manager """ # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) initial_state = State(constraints, world) - super().__init__(initial_state, workspace_url=workspace_url, policy=policy) + super().__init__(initial_state, **kwargs) + if plugins is not None: + for p in plugins: + self.register_plugin(p) self.subscribe("will_terminate_state", self._terminate_state_callback) self.subscribe("did_evm_execute_instruction", self._did_evm_execute_instruction_callback) if consts.sha3 is consts.sha3.concretize: @@ -555,7 +557,6 @@ def solidity_create_contract( :type gas: int :rtype: EVMAccount """ - if compile_args is None: compile_args = dict() @@ -582,7 +583,6 @@ def solidity_create_contract( constructor_data = ABI.serialize(constructor_types, *args) else: constructor_data = b"" - # Balance could be symbolic, lets ask the solver # Option 1: balance can not be 0 and the function is marked as not payable if not Z3Solver.instance().can_be_true(self.constraints, balance == 0): @@ -615,11 +615,11 @@ def solidity_create_contract( ) else: contract_account = self.create_contract( - owner=owner, init=md._init_bytecode, balance=balance + owner=owner, init=md._init_bytecode, balance=0, gas=gas ) - if contract_account is None: - raise EthereumError("Failed to build contract %s" % contract_name_i) + return None + self.metadata[int(contract_account)] = md deps[contract_name_i] = int(contract_account) @@ -629,11 +629,7 @@ def solidity_create_contract( if lib_name not in deps: contract_names.append(lib_name) except EthereumError as e: - logger.error(e) - self.kill() - raise - except Exception as e: - logger.info("Failed to compile contract", str(e)) + logger.info(f"Failed to build contract {contract_name_i} {str(e)}") self.kill() raise @@ -641,8 +637,8 @@ def solidity_create_contract( for state in self.ready_states: if state.platform.get_code(int(contract_account)): return contract_account + logger.info("Failed to compile contract %r", contract_names) - return None def get_nonce(self, address): # type forgiveness: @@ -699,11 +695,11 @@ def create_contract(self, owner, balance=0, address=None, init=None, name=None, self._transaction("CREATE", owner, balance, address, data=init, gas=gas) # TODO detect failure in the constructor - - self._accounts[name] = EVMContract( - address=address, manticore=self, default_caller=owner, name=name - ) - return self.accounts[name] + if self.count_ready_states(): + self._accounts[name] = EVMContract( + address=address, manticore=self, default_caller=owner, name=name + ) + return self.accounts[name] def _get_uniq_name(self, stem): count = 0 @@ -732,6 +728,24 @@ def new_address(self): if new_address not in all_addresses: return new_address + def start_block( + self, blocknumber=None, timestamp=None, difficulty=0, gaslimit=0, coinbase=None + ): + for state in self.ready_states: + world = state.platform + world.start_block( + blocknumber=blocknumber, + timestamp=timestamp, + difficulty=difficulty, + gaslimit=gaslimit, + coinbase=coinbase, + ) + + def end_block(self): + for state in self.ready_states: + world = state.platform + world.end_block() + def transaction(self, caller, address, value, data, gas=None, price=1): """ Issue a symbolic transaction in all running states @@ -815,7 +829,7 @@ def create_account(self, balance=0, address=None, code=None, name=None, nonce=No self._accounts[name] = EVMAccount(address, manticore=self, name=name) return self.accounts[name] - def _migrate_tx_expressions(self, state, caller, address, value, data): + def _migrate_tx_expressions(self, state, caller, address, value, data, gas, price): # Copy global constraints into each state. # We should somehow remember what has been copied to each state # In a second transaction we should only add new constraints. @@ -844,12 +858,18 @@ def _migrate_tx_expressions(self, state, caller, address, value, data): if isinstance(data, Array): data = ArrayProxy(data) + if issymbolic(gas): + gas = state.migrate_expression(gas) + + if issymbolic(price): + gas = state.migrate_expression(price) + for c in global_constraints: state.constrain(c) - return caller, address, value, data + return caller, address, value, data, gas, price - def _transaction(self, sort, caller, value=0, address=None, data=None, gas=21000, price=1): + def _transaction(self, sort, caller, value=0, address=None, data=None, gas=None, price=1): """ Initiates a transaction :param caller: caller account @@ -930,7 +950,9 @@ def _transaction(self, sort, caller, value=0, address=None, data=None, gas=21000 address_migrated, value_migrated, data_migrated, - ) = self._migrate_tx_expressions(state, caller, address, value, data) + gas_migrated, + price_migrated, + ) = self._migrate_tx_expressions(state, caller, address, value, data, gas, price) # Different states may CREATE a different set of accounts. Accounts # that were crated by a human have the same address in all states. @@ -946,17 +968,16 @@ def _transaction(self, sort, caller, value=0, address=None, data=None, gas=21000 state.platform.start_transaction( sort=sort, address=address_migrated, - price=price, + price=price_migrated, data=data_migrated, caller=caller_migrated, value=value_migrated, - gas=gas, + gas=gas_migrated, ) # run over potentially several states and # generating potentially several others self.run() - return address def preconstraint_for_call_transaction( @@ -1019,8 +1040,8 @@ def multi_tx_analysis( args=None, compile_args=None, ): - owner_account = self.create_account(balance=10000000000000000000, name="owner") - attacker_account = self.create_account(balance=10000000000000000000, name="attacker") + owner_account = self.create_account(balance=10 ** 10, name="owner") + attacker_account = self.create_account(balance=10 ** 10, name="attacker") # Pretty print logger.info("Starting symbolic create contract") @@ -1028,6 +1049,7 @@ def multi_tx_analysis( create_value = self.make_symbolic_value() else: create_value = 0 + contract_account = self.solidity_create_contract( solidity_filename, contract_name=contract_name, @@ -1035,6 +1057,7 @@ def multi_tx_analysis( args=args, compile_args=compile_args, balance=create_value, + gas=230000, ) if tx_account == "attacker": @@ -1077,6 +1100,7 @@ def multi_tx_analysis( address=contract_account, data=symbolic_data, value=value, + gas=230000, ) logger.info( @@ -1411,6 +1435,7 @@ def _terminate_state_callback(self, state, e): # we initiated the Tx; we need process the outcome for now. # Fixme incomplete. + """ if tx.is_human: if tx.sort == "CREATE": if tx.result == "RETURN": @@ -1421,7 +1446,7 @@ def _terminate_state_callback(self, state, e): logger.info( "Manticore exception: state should be terminated only at the end of the human transaction" ) - + """ # Human tx that ends in this wont modify the storage so finalize and # generate a testcase. FIXME This should be configurable as REVERT and # THROW; it actually changes the balance and nonce? of some accounts diff --git a/manticore/ethereum/plugins.py b/manticore/ethereum/plugins.py index 15996ad24..83365dc22 100644 --- a/manticore/ethereum/plugins.py +++ b/manticore/ethereum/plugins.py @@ -16,7 +16,8 @@ def __init__( self, regexp=r".*", mutability="both", depth="both", fallback=False, include=True, **kwargs ): """ - Constrain input based on function metadata. Include or avoid functions selected by the specified criteria. + Constrain input based on function metadata. Include or avoid functions + selected by the specified criteria. Examples: #Do not explore any human transactions that end up calling a constant function diff --git a/manticore/native/memory.py b/manticore/native/memory.py index 3e5ecdc8b..062291c03 100644 --- a/manticore/native/memory.py +++ b/manticore/native/memory.py @@ -1328,7 +1328,9 @@ def _try_get_solutions(self, address, size, access, max_solutions=0x1000, force= """ assert issymbolic(address) solver = Z3Solver.instance() - solutions = solver.get_all_values(self.constraints, address, maxcnt=max_solutions) + solutions = solver.get_all_values( + self.constraints, address, maxcnt=max_solutions, silent=True + ) crashing_condition = False for base in solutions: diff --git a/manticore/platforms/evm.py b/manticore/platforms/evm.py index 34472aa34..5fdec1a53 100644 --- a/manticore/platforms/evm.py +++ b/manticore/platforms/evm.py @@ -54,6 +54,7 @@ # pesimistic: OOG soon. If it may NOT be enough gas we ignore the normal case. A constraint is added to assert the gas is NOT enough and the other state is ignored. # ignore: Ignore gas. Do not account for it. Do not OOG. consts = config.get_group("evm") +DEFAULT_FORK = "istanbul" def globalsha3(data): @@ -80,6 +81,17 @@ def globalfakesha3(data): ), ) +consts.add( + "txfail", + default="optimistic", + description=( + "Default behavior for transaction failing because not enough funds." + "optimistic: Assume there is always enough funds to pay for value and gas. Wont fork" + "pessimistic: Assume the balance is never enough for paying fo a transaction. Wont fork" + "both: Will fork for both options if possible." + ), +) + consts.add( "calldata_max_offset", default=1024 * 1024, @@ -101,9 +113,12 @@ def globalfakesha3(data): # FIXME. We should just use a Transaction() for this PendingTransaction = namedtuple( - "PendingTransaction", ["type", "address", "price", "data", "caller", "value", "gas"] + "PendingTransaction", ["type", "address", "price", "data", "caller", "value", "gas", "failed"] ) EVMLog = namedtuple("EVMLog", ["address", "memlog", "topics"]) +BlockHeader = namedtuple( + "BlockHeader", ["blocknumber", "timestamp", "difficulty", "gaslimit", "coinbase"] +) def ceil32(x): @@ -129,6 +144,7 @@ class Transaction: "_return_data", "_result", "gas", + "_used_gas", ) def __init__( @@ -143,6 +159,7 @@ def __init__( depth=None, result=None, return_data=None, + used_gas=None, ): self.sort = sort self.address = address @@ -152,7 +169,7 @@ def __init__( self.value = value self.depth = depth self.gas = gas - self.set_result(result, return_data) + self.set_result(result, return_data, used_gas) def concretize(self, state, constrain=False): """ @@ -165,6 +182,7 @@ def concretize(self, state, constrain=False): conc_gas = state.solve_one(self.gas, constrain=constrain) conc_data = state.solve_one(self.data, constrain=constrain) conc_return_data = state.solve_one(self.return_data, constrain=constrain) + conc_used_gas = state.solve_one(self.used_gas, constrain=constrain) return Transaction( self.sort, conc_address, @@ -191,6 +209,7 @@ def to_dict(self, mevm): value=self.value, gas=self.gas, data=binascii.hexlify(self.data).decode(), + used_gas=self.used_gas, ) def dump(self, stream, state, mevm, conc_tx=None): @@ -312,7 +331,7 @@ def sort(self): @sort.setter def sort(self, sort): - if sort not in {"CREATE", "CALL", "DELEGATECALL"}: + if sort not in {"CREATE", "CALL", "CALLCODE", "DELEGATECALL"}: raise EVMException(f"Invalid transaction type: {sort}") self._sort = sort @@ -341,14 +360,23 @@ def return_data(self): @property def return_value(self): if self.result in {"RETURN", "STOP", "SELFDESTRUCT"}: - return 1 + if self.sort == "CREATE": + return self.address + else: + return 1 else: assert self.result in {"TXERROR", "REVERT", "THROW"} return 0 - def set_result(self, result, return_data=None): + @property + def used_gas(self): + return self._used_gas + + def set_result(self, result, return_data=None, used_gas=None): if getattr(self, "result", None) is not None: raise EVMException("Transaction result already set") + if not isinstance(used_gas, (int, BitVec, type(None))): + raise EVMException("Invalid used gas in Transaction") if result not in {None, "TXERROR", "REVERT", "RETURN", "THROW", "STOP", "SELFDESTRUCT"}: raise EVMException("Invalid transaction result") if result in {"RETURN", "REVERT"}: @@ -358,7 +386,7 @@ def set_result(self, result, return_data=None): ) elif result in {"STOP", "THROW", "SELFDESTRUCT"}: if return_data is None: - return_data = bytearray() + return_data = b"" if not isinstance(return_data, (bytes, bytearray, Array)) or len(return_data) != 0: raise EVMException( f"Invalid transaction return_data. Too much data ({len(return_data)}) for STOP, THROW or SELFDESTRUCT" @@ -368,6 +396,7 @@ def set_result(self, result, return_data=None): raise EVMException("Invalid transaction return_data") self._result = result self._return_data = return_data + self._used_gas = used_gas def __reduce__(self): """Implements serialization/pickle""" @@ -384,12 +413,20 @@ def __reduce__(self): self.depth, self.result, self.return_data, + self.used_gas, ), ) def __str__(self): - return "Transaction({:s}, from=0x{:x}, to=0x{:x}, value={!r}, depth={:d}, data={!r}, result={!r}..)".format( - self.sort, self.caller, self.address, self.value, self.depth, self.data, self.result + return "Transaction({:s}, from=0x{:x}, to=0x{:x}, value={!r}, depth={:d}, data={!r}, result={!r}, gas={!r} ..)".format( + self.sort, + self.caller, + self.address, + self.value, + self.depth, + self.data, + self.result, + self.gas, ) @@ -461,32 +498,31 @@ def __str__(self): return f"EndTX<{self.result}>" -class InvalidOpcode(EndTx): - """Trying to execute invalid opcode""" - +class Throw(EndTx): def __init__(self): super().__init__("THROW") -class StackOverflow(EndTx): +class InvalidOpcode(Throw): + """Trying to execute invalid opcode""" + + +class StackOverflow(Throw): """Attempted to push more than 1024 items""" - def __init__(self): - super().__init__("THROW") + pass -class StackUnderflow(EndTx): +class StackUnderflow(Throw): """Attempted to pop from an empty stack""" - def __init__(self): - super().__init__("THROW") + pass -class NotEnoughGas(EndTx): +class NotEnoughGas(Throw): """Not enough gas for operation""" - def __init__(self): - super().__init__("THROW") + pass class Stop(EndTx): @@ -499,7 +535,7 @@ def __init__(self): class Return(EndTx): """Program reached a RETURN instruction""" - def __init__(self, data=bytearray()): + def __init__(self, data=bytes()): super().__init__("RETURN", data) @@ -553,7 +589,7 @@ def wrapper(*args, **kwargs): # index is 0-indexed, but ConcretizeArgument is 1-indexed. However, this is correct # since implementation method is always a bound method (self is param 0) index = spec.args.index(arg) - if not issymbolic(args[index]): + if not issymbolic(args[index]) or isinstance(args[index], Constant): continue if not policy: policy = "SAMPLED" @@ -623,7 +659,7 @@ def __get__(self, obj, objtype=None): raise AttributeError("unreadable attribute") from types import MethodType - # return different version depending on obj._pending_transaction + @wraps(self._pre) def _pre_func(my_obj, *args, **kwargs): if my_obj._on_transaction: result = self._pos(my_obj, *args, **kwargs) @@ -651,7 +687,17 @@ def pos(self, pos): return type(self)(self._pre, pos) def __init__( - self, constraints, address, data, caller, value, bytecode, world=None, gas=210000, **kwargs + self, + constraints, + address, + data, + caller, + value, + bytecode, + world=None, + gas=None, + fork=DEFAULT_FORK, + **kwargs, ): """ Builds a Ethereum Virtual Machine instance @@ -744,6 +790,7 @@ def extend_with_zeroes(b): # self.invalid = set() # Machine state + self.evmfork = fork self._pc = 0 self.stack = [] # We maintain gas as a 512 bits internally to avoid overflows @@ -760,6 +807,27 @@ def extend_with_zeroes(b): self._used_calldata_size = 0 self._valid_jmpdests = set() self._sha3 = {} + self._refund = 0 + self._temp_call_gas = None + self._failed = False + + def fail_if(self, failed): + self._failed = Operators.OR(self._failed, failed) + + def is_failed(self): + if isinstance(self._failed, bool): + return self._failed + + self._failed = simplify(self._failed) + if isinstance(self._failed, Constant): + return self._failed.value + + def setstate(state, value): + state.platform._failed = value + + raise Concretize( + "Transaction failed", expression=self._failed, setstate=lambda a, b: None, policy="ALL" + ) @property def pc(self): @@ -810,6 +878,10 @@ def __getstate__(self): state["_valid_jumpdests"] = self._valid_jumpdests state["_check_jumpdest"] = self._check_jumpdest state["_return_data"] = self._return_data + state["evmfork"] = self.evmfork + state["_refund"] = self._refund + state["_temp_call_gas"] = self._temp_call_gas + state["_failed"] = self._failed return state def __setstate__(self, state): @@ -835,6 +907,10 @@ def __setstate__(self, state): self._valid_jumpdests = state["_valid_jumpdests"] self._check_jumpdest = state["_check_jumpdest"] self._return_data = state["_return_data"] + self.evmfork = state["evmfork"] + self._refund = state["_refund"] + self._temp_call_gas = state["_temp_call_gas"] + self._failed = state["_failed"] super().__setstate__(state) def _get_memfee(self, address, size=1): @@ -901,6 +977,13 @@ def disassemble(self): def PC(self): return self.pc + def _getcode(self, pc): + bytecode = self.bytecode + for pc_i in range(pc, len(bytecode)): + yield simplify(bytecode[pc_i]).value + while True: + yield 0 # STOP opcode + @property def instruction(self): """ @@ -914,7 +997,8 @@ def instruction(self): try: _decoding_cache = getattr(self, "_decoding_cache") except Exception: - _decoding_cache = self._decoding_cache = {} + self._decoding_cache = {} + _decoding_cache = self._decoding_cache pc = self.pc if isinstance(pc, Constant): @@ -923,18 +1007,15 @@ def instruction(self): if pc in _decoding_cache: return _decoding_cache[pc] - def getcode(): - bytecode = self.bytecode - for pc_i in range(pc, len(bytecode)): - yield simplify(bytecode[pc_i]).value - while True: - yield 0 - - instruction = EVMAsm.disassemble_one(getcode(), pc=pc, fork=DEFAULT_FORK) + instruction = EVMAsm.disassemble_one(self._getcode(pc), pc=pc, fork=self.evmfork) _decoding_cache[pc] = instruction return instruction # auxiliary funcs + def _throw(self): + self._gas = 0 + raise InvalidOpcode() + # Stack related def _push(self, value): """ @@ -986,84 +1067,48 @@ def _consume(self, fee): # pesimistic: OOG soon. If it may NOT be enough gas we ignore the normal case. A constraint is added to assert the gas is NOT enough and the other state is ignored. # ignore: Ignore gas. Do not account for it. Do not OOG. - # optimization that speed up concrete fees over symbolic gas sometimes - if not issymbolic(fee) and issymbolic(self._gas): - reps, m = getattr(self, "_mgas", (0, None)) - reps += 1 - if m is None and reps > 10: - m = Z3Solver.instance().min(self.constraints, self._gas) - self._mgas = reps, m - - if m is not None and fee < m: - self._gas -= fee - self._mgas = reps, m - fee - return - - if consts.oog in ("pedantic", "complete"): - # gas is faithfully accounted and ogg checked at instruction/BB level. - if consts.oog == "pedantic" or self.instruction.is_terminator: - # explore both options / fork - constraint = simplify(Operators.UGE(self._gas, fee)) - - # FIXME if gas can be both enough and insufficient this will - # reenter here and generate redundant queries - if isinstance(constraint, Constant): - enough_gas_solutions = (constraint.value,) # (self._gas - fee >= 0,) - elif isinstance(constraint, bool): - enough_gas_solutions = (constraint,) # (self._gas - fee >= 0,) - else: - enough_gas_solutions = Z3Solver.instance().get_all_values( - self.constraints, constraint - ) + oog_condition = simplify(Operators.ULT(self._gas, fee)) + self.fail_if(oog_condition) - if len(enough_gas_solutions) == 2: - # if gas can be both enough and insufficient, fork - raise Concretize( - "Concretize gas fee", expression=constraint, setstate=None, policy="ALL" - ) - elif enough_gas_solutions[0] is False: - # if gas if only insuficient OOG! - logger.debug( - f"Not enough gas for instruction {self.instruction.name} at 0x{self.pc:x}" - ) - raise NotEnoughGas() - else: - assert enough_gas_solutions[0] is True - # if there is enough gas keep going + self._gas = simplify(self._gas - fee) + if isinstance(self._gas, Constant) and not self._gas.taint: + self._gas = self._gas.value - elif consts.oog == "concrete": - # Keep gas concrete. Concretize symbolic fees to some values. - # this can happen only if symbolic gas is provided for the TX + def check_oog(self): + if consts.oog == "concrete": + # Keep gas concrete and ogg checked at every instruction if issymbolic(self._gas): raise ConcretizeGas() - if issymbolic(fee): - raise ConcretizeFee() + if self.is_failed(): + raise NotEnoughGas() + + if consts.oog == "pedantic": + # gas is faithfully accounted and ogg checked at every instruction + if self.is_failed(): + raise NotEnoughGas() + + elif consts.oog == "complete": + if self.instruction.is_terminator: + # gas is faithfully accounted and ogg checked at every BB + if self.is_failed(): + raise NotEnoughGas() + elif consts.oog == "optimistic": - # Try not to OOG. If it may be enough gas we ignore the OOG case. - # A constraint is added to assert the gas is enough and the OOG state is ignored. - # explore only when there is enough gas if possible - if Z3Solver.instance().can_be_true(self.constraints, Operators.UGT(self.gas, fee)): - self.constraints.add(Operators.UGT(self.gas, fee)) - else: - logger.debug( - f"Not enough gas for instruction {self.instruction.name} at 0x{self.pc:x}" - ) + self.constraints.add(self._failed == False) + if self.is_failed(): raise NotEnoughGas() - elif consts.oog == "pesimistic": + + elif consts.oog == "pessimistic": # OOG soon. If it may NOT be enough gas we ignore the normal case. # A constraint is added to assert the gas is NOT enough and the other state is ignored. # explore only when there is enough gas if possible - if Z3Solver.instance().can_be_true(self.constraints, Operators.ULE(self.gas, fee)): - self.constraints.add(Operators.ULE(self.gas, fee)) + self.constraints.add(self._failed == True) + if self.is_failed(): raise NotEnoughGas() else: - if consts.oog != "ignore": - raise EVMException("Wrong oog config variable") + assert consts.oog == "ignore", "Wrong oog config variable" # do nothing. gas is not even changed return - self._gas = simplify(self._gas - fee) - if isinstance(self._gas, Constant) and not self._gas.taint: - self._gas = self._gas.value # If everything is concrete lets just check at every instruction if not issymbolic(self._gas) and self._gas < 0: @@ -1148,6 +1193,7 @@ def _checkpoint(self): self._checkpoint_data = (pc, old_gas, instruction, arguments, fee, allocated) self._consume(fee) + self.check_oog() return self._checkpoint_data @@ -1200,7 +1246,7 @@ def _check_jmpdest(self): if should_check_jumpdest: if pc not in self._valid_jumpdests: - raise InvalidOpcode() + self._throw() def _advance(self, result=None, exception=False): if self._checkpoint_data is None: @@ -1245,9 +1291,7 @@ def setstate(state, value): else: state.platform.current_vm.pc = value - raise Concretize( - "Concretize PC", expression=expression, setstate=setstate, policy="ALL" - ) + raise Concretize("Symbolic PC", expression=expression, setstate=setstate, policy="ALL") try: self._check_jmpdest() last_pc, last_gas, instruction, arguments, fee, allocated = self._checkpoint() @@ -1322,20 +1366,26 @@ def setstate(state, value): setstate=setstate, policy=ex.policy, ) - + except NotEnoughGas: + # If tried to pay gas and failed then consume all of it + self._gas = 0 + raise except StartTx: raise except EndTx as ex: + if isinstance(ex, Throw): + self._gas = 0 self._advance(exception=True) raise def read_buffer(self, offset, size): - if issymbolic(size): + if issymbolic(size) and not isinstance(size, Constant): raise EVMException("Symbolic size not supported") if size == 0: return b"" self._allocate(offset, size) - return self.memory[offset : offset + size] + data = self.memory[offset : offset + size] + return ArrayProxy(data) def write_buffer(self, offset, data): self._allocate(offset, len(data)) @@ -1344,13 +1394,9 @@ def write_buffer(self, offset, data): def _load(self, offset, size=1): value = self.memory.read_BE(offset, size) - try: - value = simplify(value) - if not value.taint: - value = value.value - except Exception: - pass - + value = simplify(value) + if isinstance(value, Constant) and not value.taint: + value = value.value self._publish("did_evm_read_memory", offset, value, size) return value @@ -1378,7 +1424,7 @@ def safe_mul(self, a, b): def INVALID(self): """Halts execution""" - raise InvalidOpcode() + self._throw() ############################################################################ # Stop and Arithmetic Operations @@ -1463,7 +1509,7 @@ def MULMOD(self, a, b, c): def EXP_gas(self, base, exponent): """Calculate extra gas fee""" - EXP_SUPPLEMENTAL_GAS = 10 # cost of EXP exponent per byte + EXP_SUPPLEMENTAL_GAS = 50 # cost of EXP exponent per byte def nbytes(e): result = 0 @@ -1563,24 +1609,6 @@ def SAR(self, a, b): """Arithmetic Shift Right operation""" return Operators.SAR(256, b, a) - def try_simplify_to_constant(self, data): - concrete_data = bytearray() - for c in data: - simplified = simplify(c) - if isinstance(simplified, Constant): - concrete_data.append(simplified.value) - else: - # simplify by solving. probably means that we need to improve simplification - solutions = Z3Solver.instance().get_all_values( - self.constraints, simplified, 2, silent=True - ) - if len(solutions) != 1: - break - concrete_data.append(solutions[0]) - else: - data = bytes(concrete_data) - return data - def SHA3_gas(self, start, size): GSHA3WORD = 6 # Cost of SHA3 per word sha3fee = self.safe_mul(GSHA3WORD, ceil32(size) // 32) @@ -1609,7 +1637,7 @@ def ADDRESS(self): return self.address def BALANCE_gas(self, account): - return 380 # BALANCE_SUPPLEMENTAL_GAS + return 700 # BALANCE_SUPPLEMENTAL_GAS def BALANCE(self, account): """Get balance of the given account""" @@ -1674,7 +1702,7 @@ def CALLDATACOPY_gas(self, mem_offset, data_offset, size): memfee = self._get_memfee(mem_offset, size) return self.safe_add(copyfee, memfee) - # @concretized_args(size="ALL") + # @concretized_args(size="SAMPLED") def CALLDATACOPY(self, mem_offset, data_offset, size): """Copy input data in current environment to memory""" # calldata_overflow = const.calldata_overflow @@ -1689,7 +1717,7 @@ def CALLDATACOPY(self, mem_offset, data_offset, size): self._allocate(mem_offset, size) if consts.oog == "complete": - # gas reduced + # gas reduced #?? cond = Operators.ULT(self.gas, self._checkpoint_data[1]) if not Z3Solver.instance().can_be_true(self.constraints, cond): raise NotEnoughGas() @@ -1907,30 +1935,108 @@ def SLOAD(self, offset): def SSTORE_gas(self, offset, value): storage_address = self.address - GSTORAGEREFUND = 15000 - GSTORAGEKILL = 5000 - GSTORAGEMOD = 5000 - GSTORAGEADD = 20000 - - previous_value = self.world.get_storage_data(storage_address, offset) - - gascost = Operators.ITEBV( - 512, - previous_value != 0, - Operators.ITEBV(512, value != 0, GSTORAGEMOD, GSTORAGEKILL), - Operators.ITEBV(512, value != 0, GSTORAGEADD, GSTORAGEMOD), + SSSTORESENTRYGAS = ( + 2300 # Minimum gas required to be present for an SSTORE call, not consumed + ) + SSTORENOOP = 800 # Once per SSTORE operation if the value doesn't change. + SSTOREDIRTYGAS = 800 # Once per SSTORE operation if a dirty value is changed. + SSTOREINITGAS = 20000 # Once per SSTORE operation from clean zero to non-zero + SstoreInitRefund = ( + 19200 # Once per SSTORE operation for resetting to the original zero value + ) + SSTORECLEANGAS = 5000 # Once per SSTORE operation from clean non-zero to something else + SstoreCleanRefund = ( + 4200 # Once per SSTORE operation for resetting to the original non-zero value + ) + SstoreClearRefund = ( + 15000 # Once per SSTORE operation for clearing an originally existing storage slot + ) + + self.fail_if(Operators.ULT(self.gas, SSSTORESENTRYGAS)) + + # Get the storage from the snapshot took before this call + try: + original_value = self.world._callstack[-1][-2].get(offset, 0) + except IndexError: + original_value = 0 + + current_value = self.world.get_storage_data(storage_address, offset) + + def ITE(*args): + return Operators.ITEBV(512, *args) + + def AND(*args): + return Operators.AND(*args) + + gascost = ITE( + current_value == value, + SSTORENOOP, + ITE( + original_value == current_value, + ITE(original_value == 0, SSTOREINITGAS, SSTORECLEANGAS), + SSTOREDIRTYGAS, + ), + ) + refund = 0 + refund += ITE( + AND( + current_value != value, + original_value == current_value, + original_value != 0, + value == 0, + ), + SstoreClearRefund, + 0, + ) + refund += ITE( + AND( + current_value != value, + original_value != current_value, + original_value != 0, + current_value == 0, + ), + -SstoreClearRefund, + 0, + ) + refund += ITE( + AND( + current_value != value, + original_value != current_value, + original_value != 0, + current_value != 0, + value == 0, + ), + SstoreClearRefund, + 0, ) + refund += ITE( + AND( + current_value != value, + original_value != current_value, + original_value == value, + original_value == 0, + ), + SstoreInitRefund, + 0, + ) + refund += ITE( + AND( + current_value != value, + original_value != current_value, + original_value == value, + original_value != 0, + ), + SstoreCleanRefund, + 0, + ) + self._refund += simplify(refund) return gascost def SSTORE(self, offset, value): """Save word to storage""" storage_address = self.address self._publish("will_evm_write_storage", storage_address, offset, value) - # refund = Operators.ITEBV(256, - # previous_value != 0, - # Operators.ITEBV(256, value != 0, 0, GSTORAGEREFUND), - # 0) if istainted(self.pc): for taint in get_taints(self.pc): @@ -1946,6 +2052,9 @@ def JUMP(self, dest): def JUMPI(self, dest, cond): """Conditionally alter the program counter""" + # TODO(feliam) If dest is Constant we do not need to 3 queries. There would + # be only 2 options + self.pc = Operators.ITEBV(256, cond != 0, dest, self.pc + self.instruction.size) # This set ups a check for JMPDEST in the next instruction if cond != 0 self._set_check_jmpdest(cond != 0) @@ -2006,39 +2115,49 @@ def CREATE_gas(self, value, offset, size): @transact def CREATE(self, value, offset, size): """Create a new account with associated code""" - address = self.world.create_account( - address=EVMWorld.calculate_new_address( - sender=self.address, nonce=self.world.get_nonce(self.address) - ) - ) + data = self.read_buffer(offset, size) self.world.start_transaction( - "CREATE", - address, - data=self.read_buffer(offset, size), - caller=self.address, - value=value, - gas=self.gas, + "CREATE", None, data=data, caller=self.address, value=value, gas=self.gas * 63 // 64 ) - raise StartTx() @CREATE.pos # type: ignore def CREATE(self, value, offset, size): """Create a new account with associated code""" tx = self.world.last_transaction # At this point last and current tx are the same. - address = tx.address - if tx.result == "RETURN": - self.world.set_code(tx.address, tx.return_data) - else: - self.world.delete_account(address) - address = 0 - return address + return tx.return_value + + def CALL_gas(self, wanted_gas, address, value, in_offset, in_size, out_offset, out_size): + """ Dynamic gas for CALL instruction. _arguably turing complete in itself_ """ + GCALLVALUE = 9000 + GCALLNEW = 25000 + wanted_gas = Operators.ZEXTEND(wanted_gas, 512) + fee = Operators.ITEBV(512, value == 0, 0, GCALLVALUE) + known_address = False + for address_i in self.world.accounts: + known_address = Operators.OR(known_address, address == address_i) + fee += Operators.ITEBV(512, Operators.AND(known_address, value == 0), 0, GCALLNEW) + fee += self._get_memfee(in_offset, in_size) + + exception = False + available_gas = self._gas + available_gas -= fee + + exception = Operators.OR( + Operators.UGT(fee, self._gas), + Operators.ULT(self.safe_mul(available_gas, 63), available_gas), + ) + available_gas *= 63 + available_gas //= 64 - def CALL_gas(self, gas, address, value, in_offset, in_size, out_offset, out_size): - return self._get_memfee(in_offset, in_size) + temp_call_gas = Operators.ITEBV( + 512, Operators.UGT(available_gas, wanted_gas), wanted_gas, available_gas + ) + self._temp_call_gas = temp_call_gas + return temp_call_gas + fee @transact - @concretized_args(address="ACCOUNTS", gas="MINMAX", in_offset="SAMPLED", in_size="SAMPLED") + @concretized_args(address="ACCOUNTS", in_offset="SAMPLED", in_size="SAMPLED") def CALL(self, gas, address, value, in_offset, in_size, out_offset, out_size): """Message-call into an account""" self.world.start_transaction( @@ -2047,7 +2166,7 @@ def CALL(self, gas, address, value, in_offset, in_size, out_offset, out_size): data=self.read_buffer(in_offset, in_size), caller=self.address, value=value, - gas=gas, + gas=self._temp_call_gas + Operators.ITEBV(512, value != 0, 2300, 0), ) raise StartTx() @@ -2056,7 +2175,8 @@ def __pos_call(self, out_offset, out_size): data_size = len(data) size = Operators.ITEBV(256, Operators.ULT(out_size, data_size), out_size, data_size) self.write_buffer(out_offset, data[:size]) - return self.world.last_transaction.return_value + self._get_memfee(out_offset, size) + return self.world.transactions[-1].return_value @CALL.pos # type: ignore def CALL(self, gas, address, value, in_offset, in_size, out_offset, out_size): @@ -2146,15 +2266,24 @@ def THROW(self): # revert balance on CALL fail raise EndTx("THROW") + def SELFDESTRUCT_gas(self, recipient): + CreateBySelfdestructGas = 25000 + SelfdestructRefundGas = 24000 + fee = 0 + if recipient not in self.world and self.world.get_balance(self.address) != 0: + fee += CreateBySelfdestructGas + + if self.address not in self.world._deleted_accounts: + self._refund += SelfdestructRefundGas + + return fee + + @concretized_args(recipient="ACCOUNTS") def SELFDESTRUCT(self, recipient): """Halt execution and register account for later deletion""" # This may create a user account recipient = Operators.EXTRACT(recipient, 0, 160) address = self.address - # FIXME for on the known addresses - if issymbolic(recipient): - logger.info("Symbolic recipient on self destruct") - recipient = Z3Solver.instance().get_value(self.constraints, recipient) if recipient not in self.world: self.world.create_account(address=recipient) @@ -2167,7 +2296,8 @@ def SELFDESTRUCT(self, recipient): def __str__(self): m = [] for offset in range(128): - c = simplify(self.memory[offset]) + # c = simplify(self.memory[offset]) + c = self.memory[offset] try: c = c.value except Exception: @@ -2201,14 +2331,13 @@ def __str__(self): inspect.getfullargspec(implementation).args[1 : self.instruction.pops + 1] ) ) - clmn = 80 result.append( "Stack Memory" ) sp = 0 for i in list(reversed(self.stack))[:10]: - argname = args.get(sp, "top" if sp == 0 else "") + argname = args.get(sp, "") r = "" if issymbolic(i): r = "{:>12s} {:66s}".format(argname, repr(i)) @@ -2231,7 +2360,7 @@ def __str__(self): # Append gas gas = self.gas if issymbolic(gas): - gas = simplify(gas) + # gas = simplify(gas) result.append(f"Gas: {translate_to_smtlib(gas)[:20]} {gas.taint}") else: result.append(f"Gas: {gas}") @@ -2258,19 +2387,9 @@ class EVMWorld(Platform): "symbolic_function", } - def __init__( - self, - constraints, - storage=None, - blocknumber=None, - timestamp=None, - difficulty=0, - gaslimit=0, - coinbase=0, - **kwargs, - ): + def __init__(self, constraints, fork=DEFAULT_FORK, **kwargs): super().__init__(path="NOPATH", **kwargs) - self._world_state = {} if storage is None else storage + self._world_state = {} self._constraints = constraints self._callstack: List[ Tuple[Transaction, List[EVMLog], Set[int], Union[bytearray, ArrayProxy], EVM] @@ -2279,59 +2398,46 @@ def __init__( self._logs: List[EVMLog] = list() self._pending_transaction = None self._transactions: List[Transaction] = list() - - if blocknumber is None: - # assume initial byzantium block - blocknumber = 4370000 - self._blocknumber = blocknumber - - if timestamp is None: - # 1524785992; // Thu Apr 26 23:39:52 UTC 2018 - timestamp = 1524785992 - self._timestamp = timestamp - - self._difficulty = difficulty - self._gaslimit = gaslimit - self._coinbase = coinbase + self._fork = fork + self._block_header = None + self.start_block() def __getstate__(self): state = super().__getstate__() - state["pending_transaction"] = self._pending_transaction - state["logs"] = self._logs - state["world_state"] = self._world_state - state["constraints"] = self._constraints - state["callstack"] = self._callstack - state["deleted_accounts"] = self._deleted_accounts - state["transactions"] = self._transactions - state["_blocknumber"] = self._blocknumber - state["_timestamp"] = self._timestamp - state["_difficulty"] = self._difficulty - state["_gaslimit"] = self._gaslimit - state["_coinbase"] = self._coinbase + state["_pending_transaction"] = self._pending_transaction + state["_logs"] = self._logs + state["_world_state"] = self._world_state + state["_constraints"] = self._constraints + state["_callstack"] = self._callstack + state["_deleted_accounts"] = self._deleted_accounts + state["_transactions"] = self._transactions + state["_fork"] = self._fork + state["_block_header"] = self._block_header + return state def __setstate__(self, state): super().__setstate__(state) - self._constraints = state["constraints"] - self._pending_transaction = state["pending_transaction"] - self._world_state = state["world_state"] - self._deleted_accounts = state["deleted_accounts"] - self._logs = state["logs"] - self._callstack = state["callstack"] - self._transactions = state["transactions"] - self._blocknumber = state["_blocknumber"] - self._timestamp = state["_timestamp"] - self._difficulty = state["_difficulty"] - self._gaslimit = state["_gaslimit"] - self._coinbase = state["_coinbase"] + self._constraints = state["_constraints"] + self._pending_transaction = state["_pending_transaction"] + self._world_state = state["_world_state"] + self._deleted_accounts = state["_deleted_accounts"] + self._logs = state["_logs"] + self._callstack = state["_callstack"] + self._transactions = state["_transactions"] + self._fork = state["_fork"] + self._block_header = state["_block_header"] for _, _, _, _, vm in self._callstack: self.forward_events_from(vm) def try_simplify_to_constant(self, data): concrete_data = bytearray() - for c in data: + # for c in data: + for index in range(len(data)): + c = data[index] simplified = simplify(c) + if isinstance(simplified, Constant): concrete_data.append(simplified.value) else: @@ -2399,44 +2505,140 @@ def constraints(self, constraints): if self.current_vm: self.current_vm.constraints = constraints - def _open_transaction(self, sort, address, price, bytecode_or_data, caller, value, gas=2300): - assert price is not None - if self.depth > 0: - origin = self.tx_origin() - else: - origin = caller - - # If not a human tx, reset returndata - # https://github.com/ethereum/EIPs/blob/master/EIPS/eip-211.md - if self.current_vm: - self.current_vm._return_data = b"" + @property + def evmfork(self): + return self._fork - tx = Transaction( - sort, address, price, bytecode_or_data, caller, value, depth=self.depth, gas=gas + def _transaction_fee(self, sort, address, price, bytecode_or_data, caller, value): + GTXCREATE = ( + 32000 # Paid by all contract creating transactions after the Homestead transition. ) + GTXDATAZERO = 4 # Paid for every zero byte of data or code for a transaction. + GTXDATANONZERO = 16 # Paid for every non - zero byte of data or code for a transaction. + GTRANSACTION = 21000 # Paid for every transaction if sort == "CREATE": - bytecode = bytecode_or_data + tx_fee = GTXCREATE + else: + tx_fee = GTRANSACTION # Simple transaction fee + + zerocount = 0 + nonzerocount = 0 + if isinstance(bytecode_or_data, (Array, ArrayProxy)): + # if nothing was written we can assume all elements are default to zero + if len(bytecode_or_data.written) == 0: + zerocount = len(bytecode_or_data) + else: + for index in range(len(bytecode_or_data)): + try: + c = bytecode_or_data.get(index, 0) + except AttributeError: + c = bytecode_or_data[index] + + zerocount += Operators.ITEBV(256, c == 0, 1, 0) + nonzerocount += Operators.ITEBV(256, c == 0, 0, 1) + + tx_fee += zerocount * GTXDATAZERO + tx_fee += nonzerocount * GTXDATANONZERO + return simplify(tx_fee) + + def _make_vm_for_tx(self, tx): + if tx.sort == "CREATE": + bytecode = tx.data data = bytes() else: - bytecode = self.get_code(address) - data = bytecode_or_data + bytecode = self.get_code(tx.address) + data = tx.data if tx.sort == "DELEGATECALL": # So at a DELEGATECALL the environment should look exactly the same as the original tx # This means caller, value and address are the same as prev tx - assert value == 0 + assert tx.value == 0 address = self.current_transaction.address caller = self.current_transaction.caller value = self.current_transaction.value + else: + address = tx.address + caller = tx.caller + value = tx.value + + gas = tx.gas vm = EVM(self._constraints, address, data, caller, value, bytecode, world=self, gas=gas) + if self.depth == 0: + # Only at human level we need to debit the tx_fee from the gas + # In case of an internal tx the CALL-like instruction will + # take the fee by itself + tx_fee = self._transaction_fee( + tx.sort, tx.address, tx.price, tx.data, tx.caller, tx.value + ) + vm._consume(tx_fee) + return vm + + def _open_transaction(self, sort, address, price, bytecode_or_data, caller, value, gas=None): + """ + This try to opens a transaction. + + :param sort: CREATE, CALL, CALLCODE, STATICCALL, DELEGATECALL + :param address: the destination address + :param price: the gas price. Used at human transactions + :param bytecode_or_data: the calldata or bytecode in creates + :param caller: the caller account + :param value: wei to transfer + :param gas: gas budget + :return: True if the transaction got accepted (enough balance to pay for stuff) + """ + # sort + if sort not in {"CALL", "CREATE", "DELEGATECALL", "CALLCODE", "STATICCALL"}: + raise EVMException(f"Transaction type '{sort}' not supported") + + if caller not in self.accounts: + logger.info("Caller not in account") + raise EVMException( + f"Caller account {hex(caller)} does not exist; valid accounts: {list(map(hex, self.accounts))}" + ) + + if sort == "CREATE": + expected_address = self.new_address(sender=caller) + if address is None: + address = expected_address + if address != expected_address: + raise EthereumError( + f"Error: contract created from address {hex(caller)} with nonce {self.get_nonce(caller)} was expected to be at address {hex(expected_address)}, but create_contract was called with address={hex(address)}" + ) + + if address not in self.accounts: + logger.info("Address does not exists creating it.") + # Creating an unaccessible account + self.create_account(address=address, nonce=int(sort != "CREATE")) + tx = Transaction( + sort, address, price, bytecode_or_data, caller, value, depth=self.depth, gas=gas + ) self._publish("will_open_transaction", tx) + # Send the tx funds (We know there are enough at this point) + if self.depth == 0: + # Debit full gas budget in advance + aux_price = Operators.ZEXTEND(tx.price, 512) + aux_gas = Operators.ZEXTEND(tx.gas, 512) + self.sub_from_balance(caller, aux_price * aux_gas) + self.send_funds(tx.caller, tx.address, tx.value) + + if tx.address not in self.accounts: + self.create_account(tx.address) + + # If not a human tx, reset returndata + # https://github.com/ethereum/EIPs/blob/master/EIPS/eip-211.md + if self.current_vm: + self.current_vm._return_data = b"" + + vm = self._make_vm_for_tx(tx) + self._callstack.append( (tx, self.logs, self.deleted_accounts, copy.copy(self.get_storage(address)), vm) ) self.forward_events_from(vm) self._publish("did_open_transaction", tx) + return True def _close_transaction(self, result, data=None, rollback=False): self._publish("will_close_transaction", self._callstack[-1][0]) @@ -2448,27 +2650,53 @@ def _close_transaction(self, result, data=None, rollback=False): # https://github.com/ethereum/EIPs/blob/master/EIPS/eip-211.md if data is not None and self.current_vm is not None: self.current_vm._return_data = data - if rollback: self._set_storage(vm.address, account_storage) self._logs = logs + # Return the transaction value self.send_funds(tx.address, tx.caller, tx.value) else: self._deleted_accounts = deleted_accounts - # FIXME: BUG: a CREATE can be successful and still return an empty contract :shrug: - if not issymbolic(tx.caller) and ( - tx.sort == "CREATE" or not self._world_state[tx.caller]["code"] - ): - # Increment the nonce if this transaction created a contract, or if it was called by a non-contract account - self.increase_nonce(tx.caller) + self.increase_nonce(tx.caller) + + if result in {"THROW"}: + unused_gas = 0 + refund = 0 + else: + unused_gas = vm._gas + refund = vm._refund + + used_gas = Operators.ZEXTEND(tx.gas, 512) - unused_gas + refund = Operators.ITEBV(512, Operators.UGE(refund, used_gas // 2), used_gas // 2, refund) if tx.is_human: for deleted_account in self._deleted_accounts: if deleted_account in self._world_state: del self._world_state[deleted_account] - tx.set_result(result, data) - self._transactions.append(tx) + unused_fee = unused_gas * tx.price + used_fee = used_gas * tx.price + self.add_to_balance(tx.caller, unused_fee) + self.add_to_balance(tx.caller, refund * tx.price) + if self.block_coinbase() in self: + self.add_to_balance(self.block_coinbase(), used_fee - refund * tx.price) + else: + logger.info( + "Coinbase not set. Throwing %r weis for the gas", used_fee - refund * tx.price + ) + else: + # if not rollback: + # Refund unused gas to caller if + self.current_vm._gas += unused_gas + self.current_vm._refund += refund + if tx.sort == "CREATE": + if result in ("RETURN", "STOP"): + # vm.consume(len(tx.return_data) * GCREATEDATAGAS) + self.set_code(tx.address, data) + else: + self.delete_account(tx.address) + tx.set_result(result, data, used_gas - refund) + self._transactions.append(tx) self._publish("did_close_transaction", tx) if self.depth == 0: @@ -2482,7 +2710,7 @@ def all_transactions(self): @property def transactions(self): """Completed completed transaction""" - return tuple((tx for tx in self._transactions if tx.result != "TXERROR")) + return tuple(self._transactions) @property def human_transactions(self): @@ -2642,15 +2870,6 @@ def _set_storage(self, address, storage): def get_nonce(self, address): if issymbolic(address): raise ValueError(f"Cannot retrieve the nonce of symbolic address {address}") - elif address not in self._world_state: - # assume that the caller is a regular account, so initialize its nonce to zero - ret = 0 - elif "nonce" not in self._world_state[address]: - if self._world_state[address]["code"]: - # this is a contract account, so set the nonce to 1 per EIP 161 - ret = 1 - else: - ret = 0 else: ret = self._world_state[address]["nonce"] return ret @@ -2661,18 +2880,28 @@ def increase_nonce(self, address): return new_nonce def set_balance(self, address, value): + if isinstance(value, BitVec): + value = Operators.ZEXTEND(value, 512) self._world_state[int(address)]["balance"] = value def get_balance(self, address): if address not in self._world_state: return 0 - return self._world_state[address]["balance"] + return Operators.EXTRACT(self._world_state[address]["balance"], 0, 256) def add_to_balance(self, address, value): - assert address in self._world_state + if isinstance(value, BitVec): + value = Operators.ZEXTEND(value, 512) self._world_state[address]["balance"] += value + def sub_from_balance(self, address, value): + if isinstance(value, BitVec): + value = Operators.ZEXTEND(value, 512) + self._world_state[address]["balance"] -= value + def send_funds(self, sender, recipient, value): + if isinstance(value, BitVec): + value = Operators.ZEXTEND(value, 512) self._world_state[sender]["balance"] -= value self._world_state[recipient]["balance"] += value @@ -2698,25 +2927,53 @@ def log_storage(self, addr): pass def add_refund(self, value): - pass + self._refund += value + + def sub_refund(self, value): + self._refund -= value def block_prevhash(self): return 0 + # Block header related + def start_block( + self, + blocknumber=4370000, + timestamp=1524785992, + difficulty=0x200, + gaslimit=0x7FFFFFFF, + coinbase=0, + ): + if coinbase not in self.accounts and coinbase != 0: + logger.info("Coinbase account does not exists") + self.create_account(coinbase) + + self._block_header = BlockHeader(blocknumber, timestamp, difficulty, gaslimit, coinbase) + + def end_block(self, block_reward=None): + coinbase = self.block_coinbase() + if coinbase not in self: + raise EVMException("Coinbase not set") + + if block_reward is None: + block_reward = 2000000000000000000 # 2 eth + self.add_to_balance(self.block_coinbase(), block_reward) + # self._block_header = None + def block_coinbase(self): - return self._coinbase + return self._block_header.coinbase def block_timestamp(self): - return self._timestamp + return self._block_header.timestamp def block_number(self): - return self._blocknumber + return self._block_header.blocknumber def block_difficulty(self): - return self._difficulty + return self._block_header.difficulty def block_gaslimit(self): - return self._gaslimit + return self._block_header.gaslimit def block_hash(self, block_number=None, force_recent=True): """ @@ -2819,7 +3076,7 @@ def create_account(self, address=None, balance=0, code=None, storage=None, nonce # nonce default to initial nonce if nonce is None: # As per EIP 161, contract accounts are initialized with a nonce of 1 - nonce = 1 if code else 0 + nonce = 1 if len(code) > 0 else 0 if address is None: address = self.new_address() @@ -2869,7 +3126,9 @@ def create_account(self, address=None, balance=0, code=None, storage=None, nonce def create_contract(self, price=0, address=None, caller=None, balance=0, init=None, gas=None): """ - Create a contract account. Sends a transaction to initialize the contract + Initiates a CREATE a contract account. + Sends a transaction to initialize the contract. + Do a world.run() after this to explore all _possible_ outputs :param address: the address of the new account, if known. If omitted, a new address will be generated as closely to the Yellow Paper as possible. :param balance: the initial balance of the account in Wei @@ -2883,30 +3142,24 @@ def create_contract(self, price=0, address=None, caller=None, balance=0, init=No This is done when the byte code in the init byte array is actually run on the network. """ - expected_address = self.create_account(self.new_address(sender=caller)) - if address is None: - address = expected_address - elif caller is not None and address != expected_address: - raise EthereumError( - f"Error: contract created from address {hex(caller)} with nonce {self.get_nonce(caller)} was expected to be at address {hex(expected_address)}, but create_contract was called with address={hex(address)}" - ) self.start_transaction( "CREATE", address, price=price, data=init, caller=caller, value=balance, gas=gas ) - self._process_pending_transaction() return address def transaction(self, address, price=0, data="", caller=None, value=0, gas=2300): + """Initiates a CALL transaction on current state. + Do a world.run() after this to explore all _possible_ outputs + """ self.start_transaction( "CALL", address, price=price, data=data, caller=caller, value=value, gas=gas ) - self._process_pending_transaction() def start_transaction( self, sort, address, *, price=None, data=None, caller=None, value=0, gas=2300 ): """ - Initiate a transaction + Initiate a transaction. :param sort: the type of transaction. CREATE or CALL or DELEGATECALL :param address: the address of the account which owns the code that is executing. @@ -2916,10 +3169,12 @@ def start_transaction( :param value: the value, in Wei, passed to this account as part of the same procedure as execution. One Ether is defined as being 10**18 Wei. :param bytecode: the byte array that is the machine code to be executed. :param gas: gas budget for this transaction. + :param failed: True if the transaction must fail """ assert self._pending_transaction is None, "Already started tx" + assert caller is not None self._pending_transaction = PendingTransaction( - sort, address, price, data, caller, value, gas + sort, address, price, data, caller, value, gas, None ) def _constraint_to_accounts(self, address, include_zero=False, ty="both"): @@ -2948,15 +3203,26 @@ def _constraint_to_accounts(self, address, include_zero=False, ty="both"): return cond def _pending_transaction_concretize_address(self): - sort, address, price, data, caller, value, gas = self._pending_transaction + sort, address, price, data, caller, value, gas, failed = self._pending_transaction if issymbolic(address): def set_address(state, solution): world = state.platform - world._pending_transaction = (sort, solution, price, data, caller, value, gas) + world._pending_transaction = ( + sort, + solution, + price, + data, + caller, + value, + gas, + failed, + ) + # Assuming this condition has at least one solution cond = self._constraint_to_accounts(address, ty="contract", include_zero=False) self.constraints.add(cond) + raise Concretize( "Concretizing address on transaction", expression=address, @@ -2965,15 +3231,26 @@ def set_address(state, solution): ) def _pending_transaction_concretize_caller(self): - sort, address, price, data, caller, value, gas = self._pending_transaction + sort, address, price, data, caller, value, gas, failed = self._pending_transaction if issymbolic(caller): def set_caller(state, solution): world = state.platform - world._pending_transaction = (sort, address, price, data, solution, value, gas) + world._pending_transaction = ( + sort, + address, + price, + data, + solution, + value, + gas, + failed, + ) # Constrain it so it can range over all normal accounts + # TODO: document and log this is loosing completness cond = self._constraint_to_accounts(caller, ty="normal") + self.constraints.add(cond) raise Concretize( "Concretizing caller on transaction", @@ -2982,71 +3259,90 @@ def set_caller(state, solution): policy="ALL", ) - def _process_pending_transaction(self): - # Nothing to do here if no pending transactions - if self._pending_transaction is None: - return - sort, address, price, data, caller, value, gas = self._pending_transaction + def _pending_transaction_failed(self): + sort, address, price, data, caller, value, gas, failed = self._pending_transaction + + # Initially the failed flag is not set. For now we need the caller to be + # concrete so the caller balance is easy to get. Initialize falied here + if failed is None: + # Check depth + failed = self.depth >= 1024 + # Fork on enough funds for value and gas + if not failed: + aux_src_balance = Operators.ZEXTEND(self.get_balance(caller), 512) + aux_value = Operators.ZEXTEND(value, 512) + enough_balance = Operators.UGE(aux_src_balance, aux_value) + if self.depth == 0: + # take the gas from the balance + aux_price = Operators.ZEXTEND(price, 512) + aux_gas = Operators.ZEXTEND(gas, 512) + aux_fee = aux_price * aux_gas + # Iff a human tx debit the fee + enough_balance = Operators.AND( + enough_balance, Operators.UGE(aux_src_balance - aux_value, aux_fee) + ) + failed = Operators.NOT(enough_balance) + self._pending_transaction = sort, address, price, data, caller, value, gas, failed - if sort not in {"CALL", "CREATE", "DELEGATECALL", "CALLCODE", "STATICCALL"}: - if sort == "STATICCALL": - # TODO: Remove this once Issue #1168 is resolved - raise EVMException( - f"The STATICCALL opcode is not yet supported; see https://github.com/trailofbits/manticore/issues/1168" - ) - else: - raise EVMException(f"Transaction type '{sort}' not supported") + if issymbolic(failed): + # optimistic/pesimistic is inverted as the expresion represents fail + policy = {"optimistic": "PESSIMISTIC", "pessimistic": "OPTIMISTIC"}.get( + consts.txfail, "ALL" + ) - if self.depth > 0: - assert price is None, "Price should not be used in internal transactions" - price = self.tx_gasprice() + def set_failed(state, solution): + world = state.platform + world._pending_transaction = ( + sort, + address, + price, + data, + caller, + value, + gas, + solution, + ) - if price is None: - raise EVMException("Need to set a gas price on human tx") - self._pending_transaction_concretize_address() - self._pending_transaction_concretize_caller() - if caller not in self.accounts: - raise EVMException( - f"Caller account {hex(caller)} does not exist; valid accounts: {list(map(hex, self.accounts))}" + raise Concretize( + "Concretizing tx-fail on transaction", + expression=failed, + setstate=set_failed, + policy=policy, ) - if address not in self.accounts: - # Creating an unaccessible account - self.create_account(address=address) + if self.depth != 0: + price = 0 + aux_price = Operators.ZEXTEND(price, 512) + aux_gas = Operators.ZEXTEND(gas, 512) + tx_fee = Operators.ITEBV(512, self.depth == 0, aux_price * aux_gas, 0) + aux_src_balance = Operators.ZEXTEND(self.get_balance(caller), 512) + aux_value = Operators.ZEXTEND(value, 512) + enough_balance = Operators.UGE(aux_src_balance, aux_value + tx_fee) + return failed - # Check depth - failed = self.depth > 1024 - - # Fork on enough funds - if not failed: - src_balance = self.get_balance(caller) - enough_balance = Operators.UGE(src_balance, value) - enough_balance_solutions = Z3Solver.instance().get_all_values( - self._constraints, enough_balance - ) + def _process_pending_transaction(self): + # Nothing to do here if no pending transactions + if self._pending_transaction is None: + return + sort, address, price, data, caller, value, gas, failed = self._pending_transaction + # caller + self._pending_transaction_concretize_caller() + # to/address + self._pending_transaction_concretize_address() + # check onough balance for the value + failed = self._pending_transaction_failed() - if set(enough_balance_solutions) == {True, False}: - raise Concretize( - "Forking on available funds", - expression=enough_balance, - setstate=lambda a, b: None, - policy="ALL", - ) - failed = set(enough_balance_solutions) == {False} - # processed + # done concretizing stuff self._pending_transaction = None - # Here we have enough funds and room in the callstack - # CALLCODE and DELEGATECALL do not send funds - if sort in ("CALL", "CREATE"): - self.send_funds(caller, address, value) - self._open_transaction(sort, address, price, data, caller, value, gas=gas) - - if failed: - self._close_transaction("TXERROR", rollback=True) - # Transaction to normal account - elif sort in ("CALL", "DELEGATECALL", "CALLCODE") and not self.get_code(address): - self._close_transaction("STOP") + if not failed: + self._open_transaction(sort, address, price, data, caller, value, gas=gas) + else: + tx = Transaction( + sort, address, price, data, caller, value, depth=self.depth + 1, gas=gas + ) + tx.set_result("TXERROR") + self._transactions.append(tx) def dump(self, stream, state, mevm, message): from ..ethereum.manticore import calculate_coverage, flagged @@ -3059,13 +3355,13 @@ def dump(self, stream, state, mevm, message): if last_tx: at_runtime = last_tx.sort != "CREATE" - address, offset, at_init = state.context["evm.trace"][-1] + address, offset, at_init = state.context.get("evm.trace", ((None, None, None),))[-1] assert last_tx.result is not None or at_runtime != at_init # Last instruction if last tx was valid if str(state.context["last_exception"]) != "TXERROR": metadata = mevm.get_metadata(blockchain.last_transaction.address) - if metadata is not None: + if metadata is not None and address is not None: stream.write("Last instruction at contract %x offset %x\n" % (address, offset)) source_code_snippet = metadata.get_source_for(offset, at_runtime) if source_code_snippet: diff --git a/manticore/utils/config.py b/manticore/utils/config.py index f6841ac82..5d3986488 100644 --- a/manticore/utils/config.py +++ b/manticore/utils/config.py @@ -44,11 +44,12 @@ def value(self): return self._value @value.setter - def value(self, value): + def value(self, val): # Forgiveness/Enums support from_string - if isinstance(self.default, Enum) and isinstance(value, str): - value = self.default.from_string(value) - self._value = value + if isinstance(self.default, Enum) and isinstance(val, str): + self._value = self.default.from_string(val) + else: + self._value = val class _Group: diff --git a/setup.py b/setup.py index 332ed2bff..d40169394 100644 --- a/setup.py +++ b/setup.py @@ -18,11 +18,14 @@ def rtd_dependent_deps(): lint_deps = ["black==19.10b0", "mypy==0.770"] +auto_test_deps = ["py-evm"] + # Development dependencies without keystone dev_noks = ( native_deps + ["coverage", "Sphinx", "pytest==5.3.0", "pytest-xdist==1.30.0", "pytest-cov==2.8.1", "jinja2"] + lint_deps + + auto_test_deps ) extra_require = { @@ -52,8 +55,8 @@ def rtd_dependent_deps(): "pyyaml", "pysha3", "prettytable", - "rlp", "ply", + "rlp", "crytic-compile>=0.1.1", "wasm", "dataclasses; python_version < '3.7'", diff --git a/tests/auto_generators/make_VMTests.py b/tests/auto_generators/make_VMTests.py index b0ffc4d90..bd32b30a4 100644 --- a/tests/auto_generators/make_VMTests.py +++ b/tests/auto_generators/make_VMTests.py @@ -1,416 +1,365 @@ """ -This script generates VMTests that are used to check EVM's Frontier fork correctness. +This script generates VMTests that are used to check EVM's Istanbul fork correctness. ### TO GENERATE ALL: ## Initialize env: -cd manticore/tests/ && mkdir -p ethereum_vm/VMTests_concrete && mkdir ethereum_vm/VMTests_symbolic +cd manticore/tests/ && mkdir -p ethereum_vm/VMTests_concrete git clone https://github.com/ethereum/tests --depth=1 -## Generate concrete tests: -for i in ./tests/VMTests/*; do python ./auto_generators/make_VMTests.py $i; done - -## Generate symbolic tests: -for i in ./tests/VMTests/*; do python ./auto_generators/make_VMTests.py $i --symbolic; done - -## Remove the eth tests repo -rm -rf ./tests # cleanup/remove the ethereum/tests repo +## Get help +python make_VMTest.py --help +## Generate concrete tests: +for i in tests/BlockchainTests/ValidBlocks/VMTests/*/*json; do python make_VMTest.py -i $i --fork Istanbul -o ethereum_vm/VMTests_concrete; done -### To test just one: -python ../auto_generators/make_VMTests.py ./tests/VMTests/VMTests """ -import json -import os +import argparse import sys -from binascii import unhexlify - -import hashlib +import logging +import os +import json import pyevmasm as EVMAsm +from binascii import unhexlify -def gen_test(testcase, filename, symbolic, skip): - output = """ @unittest.skip('Gas or performance related')\n""" if skip else "" - - # Sanity checks - - # We don't use those! - testcase.pop("_info") - assert len(testcase.pop("callcreates", [])) == 0 - - output += generate_pre_output(testcase, filename, symbolic) - - if "post" not in testcase: - output += """ - # If test end in exception check it here - self.assertTrue(result == 'THROW')""" - else: - output += generate_post_output(testcase) - - return output - - -def generate_pre_output(testcase, filename, symbolic): - testname = (os.path.split(filename)[1].replace("-", "_")).split(".")[0] - bytecode = unhexlify(testcase["exec"]["code"][2:]) - disassemble = "" - try: - # add silent=True when evmasm supports it - disassemble = "\n ".join(EVMAsm.disassemble(bytecode).split("\n")) - except Exception as e: - pass - - with open(filename, "rb") as f: - sha256sum = hashlib.sha256(f.read()).hexdigest() - - output = f''' - def test_{testname}(self): - """ - Testcase taken from https://github.com/ethereum/tests - File: {os.path.split(filename)[1]} - sha256sum: {sha256sum} - Code: {disassemble} - """ - ''' - - if symbolic: - output += """ - def solve(val): - return self._solve(constraints, val) -""" - else: - output += ''' - def solve(val): - """ - Those tests are **auto-generated** and `solve` is used in symbolic tests. - So yes, this returns just val; it makes it easier to generate tests like this. - """ - return to_constant(val) -''' - - env = testcase["env"] - - gaslimit = int(env["currentGasLimit"], 0) - blocknumber = int(env["currentNumber"], 0) - timestamp = int(env["currentTimestamp"], 0) - difficulty = int(env["currentDifficulty"], 0) - coinbase = int(env["currentCoinbase"], 0) - output += f""" - constraints = ConstraintSet() -""" - - def format_bitvec(name, val, bits=256, symbolic_name=None): - if symbolic_name is None: - symbolic_name = name - - return f""" - {name} = constraints.new_bitvec({bits}, name='{symbolic_name}') - constraints.add({name} == {val}) -""" - - def format_var(name, val): - return f""" - {name} = {val}""" - - # Spawns/creates bitvectors in symbolic or pure variables in concrete - formatter = format_bitvec if symbolic else format_var - for var in ("blocknumber", "timestamp", "difficulty", "coinbase", "gaslimit"): - output += formatter(var, locals()[var]) +total_count = 0 +DEFAULT_FORK = "Istanbul" - output += f""" - world = evm.EVMWorld(constraints, blocknumber=blocknumber, timestamp=timestamp, difficulty=difficulty, - coinbase=coinbase, gaslimit=gaslimit) - """ +real_open = open - for address, account in testcase["pre"].items(): - assert account.keys() == {"code", "nonce", "balance", "storage"} - account_address = int(address, 0) - account_code = account["code"][2:] - account_nonce = int(account["nonce"], 0) - account_balance = int(account["balance"], 0) +def fake_open(filename, mode="r", *args, **kwargs): + """ Replace normal global open with this for a wuick dry run """ + from io import StringIO - if symbolic: - postfix = hex(account_address) - output += f""" - acc_addr = {hex(account_address)} - acc_code = unhexlify('{account_code}') - """ - output += format_bitvec( - "acc_balance", account_balance, symbolic_name=f"balance_{postfix}" - ) - output += format_bitvec("acc_nonce", account_nonce, symbolic_name=f"nonce_{postfix}") - else: - output += f""" - acc_addr = {hex(account_address)} - acc_code = unhexlify('{account_code}') - acc_balance = {account_balance} - acc_nonce = {account_nonce} -""" + logging.info("Fake openning %r", (filename, mode) + args) + if os.path.exists(filename): + return StringIO(real_open(filename, "r").read()) + return StringIO() - output += f""" - world.create_account(address=acc_addr, balance=acc_balance, code=acc_code, nonce=acc_nonce) -""" - for key, value in account["storage"].items(): - if symbolic: - postfix = hex(account_address) - output += format_bitvec("key", key, symbolic_name=f"storage_key_{postfix}") - output += format_bitvec("value", value, symbolic_name=f"storage_value_{postfix}") - output += """ - world.set_storage_data(acc_addr, key, value) -""" - else: - output += f""" - world.set_storage_data(acc_addr, {key}, {value}) -""" - address = int(testcase["exec"]["address"], 0) - caller = int(testcase["exec"]["caller"], 0) - code = testcase["exec"]["code"][2:] - calldata = unhexlify(testcase["exec"]["data"][2:]) - gas = int(testcase["exec"]["gas"], 0) - price = int(testcase["exec"]["gasPrice"], 0) - origin = int(testcase["exec"]["origin"], 0) - value = int(testcase["exec"]["value"], 0) - assert testcase["exec"].keys() == { - "address", - "caller", - "code", - "data", - "gas", - "gasPrice", - "origin", - "value", - } - - # Need to check if origin is diff from caller. we do not support those tests - assert origin == caller, "test type not supported" - assert ( - testcase["pre"]["0x{:040x}".format(address)]["code"][2:] == code - ), "test type not supported" - - output += f""" - address = {hex(address)} - caller = {hex(caller)}""" - - if symbolic: - output += format_bitvec("price", price) - output += format_bitvec("value", value) - output += format_bitvec("gas", gas) - else: - output += f""" - price = {hex(price)} - value = {value} - gas = {gas}""" - - if calldata: - if symbolic: - output += f""" - data = constraints.new_array(index_max={len(calldata)}) - constraints.add(data == {calldata}) -""" - else: - output += f""" - data = {calldata}""" +def get_caller(nonce, price, gas, address, value, calldata, v, r, s): + if address is None: + to = b"" else: - output += f""" - data = ''""" - - output += f""" - # open a fake tx, no funds send - world._open_transaction('CALL', address, price, data, caller, value, gas=gas) - - # This variable might seem redundant in some tests - don't forget it is auto generated - # and there are cases in which we need it ;) - result, returndata = self._test_run(world) - - # World sanity checks - those should not change, right? - self.assertEqual(solve(world.block_number()), {blocknumber}) - self.assertEqual(solve(world.block_gaslimit()), {gaslimit}) - self.assertEqual(solve(world.block_timestamp()), {timestamp}) - self.assertEqual(solve(world.block_difficulty()), {difficulty}) - self.assertEqual(solve(world.block_coinbase()), {hex(coinbase)}) -""" - - return output - - -def generate_post_output(testcase): - output = "" - - for address, account in testcase["post"].items(): - assert account.keys() == {"code", "nonce", "balance", "storage"} - - account_address = int(address, 0) - account_code = account["code"][2:] - account_nonce = int(account["nonce"], 0) - account_balance = int(account["balance"], 0) - - output += f""" - # Add post checks for account {hex(account_address)} - # check nonce, balance, code - self.assertEqual(solve(world.get_nonce({hex(account_address)})), {account_nonce}) - self.assertEqual(solve(world.get_balance({hex(account_address)})), {account_balance}) - self.assertEqual(world.get_code({hex(account_address)}), unhexlify('{account_code}'))""" - - if account["storage"]: - output += """ - # check storage""" - - for key, value in account["storage"].items(): - output += f""" - self.assertEqual(solve(world.get_storage_data({hex(account_address)}, {key})), {value})""" - - output += f""" - # check outs - self.assertEqual(returndata, unhexlify('{testcase['out'][2:]}'))""" - - output += """ - # check logs - logs = [Log(unhexlify('{:040x}'.format(l.address)), l.topics, solve(l.memlog)) for l in world.logs] - data = rlp.encode(logs)""" - output += f""" - self.assertEqual(sha3.keccak_256(data).hexdigest(), '{testcase['logs'][2:]}') -""" - - output += f""" - # test used gas - self.assertEqual(solve(world.current_vm.gas), {int(testcase['gas'], 0)})""" - - return output - - -if __name__ == "__main__": - if len(sys.argv) < 2: - print(__doc__) - sys.exit() - - symbolic = "--symbolic" in sys.argv - - filename_or_folder = os.path.abspath(sys.argv[1]) - - output = f'''"""DO NOT MODIFY: Tests generated from `{os.path.join(*filename_or_folder.split('/')[-2:])}` with make_VMTests.py""" + to = unhexlify("%040x" % address) + # pip install py-evm + from eth.vm.forks.frontier.transactions import FrontierTransaction + + t = FrontierTransaction( + nonce=nonce, + gas_price=price, + gas=gas, + to=to, # Can be the empty string. + value=value, + data=calldata, + v=v, + r=r, + s=s, + ) + return int.from_bytes(t.sender, "big") + + +def gen_header(testcases): + header = f'''"""DO NOT MODIFY: Tests generated from `tests/` with {sys.argv[0]}""" import unittest from binascii import unhexlify +from manticore import ManticoreEVM, Plugin +from manticore.utils import config +''' -import rlp + if any("logs" in testcase for testcase in testcases.values()): + body += """ import sha3 +import rlp from rlp.sedes import ( CountableList, BigEndianInt, Binary, ) - -from manticore.core.smtlib import ConstraintSet, Z3Solver # Ignore unused import in non-symbolic tests! -from manticore.core.smtlib.visitors import to_constant -from manticore.platforms import evm -from manticore.utils import config -from manticore.core.state import Concretize - - - class Log(rlp.Serializable): fields = [ ('address', Binary.fixed_length(20, allow_empty=True)), ('topics', CountableList(BigEndianInt(32))), ('data', Binary()) ] +""" + header += """consts = config.get_group('core') +consts.mprocessing = consts.mprocessing.single +consts = config.get_group('evm') +consts.oog = 'pedantic' -class EVMTest_{os.path.splitext(os.path.basename(filename_or_folder))[0]}(unittest.TestCase): +class EVMTest(unittest.TestCase): # https://nose.readthedocs.io/en/latest/doc_tests/test_multiprocess/multiprocess.html#controlling-distribution _multiprocess_can_split_ = True # https://docs.python.org/3.7/library/unittest.html#unittest.TestCase.maxDiff maxDiff = None - SAVED_DEFAULT_FORK = evm.DEFAULT_FORK - - @classmethod - def setUpClass(cls): - consts = config.get_group('evm') - consts.oog = 'pedantic' - evm.DEFAULT_FORK = 'frontier' - - @classmethod - def tearDownClass(cls): - evm.DEFAULT_FORK = cls.SAVED_DEFAULT_FORK - - def _test_run(self, world): - result = None - returndata = b'' - try: - while True: - try: - world.current_vm.execute() - except Concretize as e: - value = self._solve(world.constraints, e.expression) - class fake_state:pass - fake_state = fake_state() - fake_state.platform = world - e.setstate(fake_state, value) - except evm.EndTx as e: - result = e.result - if result in ('RETURN', 'REVERT'): - returndata = self._solve(world.constraints, e.data) - except evm.StartTx as e: - self.fail('This tests should not initiate an internal tx (no CALLs allowed)') - return result, returndata - - def _solve(self, constraints, val): - results = Z3Solver.instance().get_all_values(constraints, val, maxcnt=3) - # We constrain all values to single values! - self.assertEqual(len(results), 1) - return results[0] +""" + return header + + +def gen_footer(testcase): + footer = """ + +if __name__ == '__main__': + unittest.main()""" + return footer + + +def gen_body(name, testcase): + body = f''' + def test_{name}(self): + """ + Testcase taken from https://github.com/ethereum/tests + Source: {testcase['_info']['source']} + """ + class UsedGas(Plugin): + @property + def used_gas(self): + with self.locked_context() as ctx: + return ctx['test_used_gas'] + @used_gas.setter + def used_gas(self, value): + with self.locked_context() as ctx: + ctx['test_used_gas']=value + + def did_close_transaction_callback(self, state, tx): + if tx.is_human: + self.used_gas = tx.used_gas + + used_gas_plugin = UsedGas() + m = ManticoreEVM(workspace_url="mem:", plugins=(used_gas_plugin,)) ''' + for address, account in testcase["pre"].items(): + account_address = int(address, 0) + account_code = account["code"][2:] + account_nonce = int(account["nonce"], 0) + account_balance = int(account["balance"], 0) - if os.path.isdir(filename_or_folder): - folder = filename_or_folder + disassembly = EVMAsm.disassemble(unhexlify(account_code), fork=DEFAULT_FORK.lower()) + disassembly = ( + '\n """' + + "\n " + + "\n ".join(disassembly.split("\n")) + + '\n """' + ) + body += f""" + {disassembly if account_code else ''} + m.create_account(address={hex(account_address)}, + balance={account_balance}, + code={"unhexlify('"+account_code+"')" if account_code else "b''"}, + nonce={account_nonce})""" + + if "storage" in account and account["storage"]: + body += """ + for state in m.all_states: + world = state.platform""" - print(f"Generating tests from dir {folder}...", file=sys.stderr) - cnt = 0 + for key, value in account["storage"].items(): + body += f""" + world.set_storage_data({hex(account_address)}, {key}, {value})""" + + coinbases = set() + for block in testcase["blocks"]: + blockheader = block["blockHeader"] + coinbases.add(blockheader["coinbase"]) + for coinbase in coinbases: + body += f""" + #coinbase + m.create_account(address={coinbase}, + balance=0, + code=b'', + nonce=0) + """ - for filename in os.listdir(folder): - if not filename.endswith(".json"): - continue + for block in testcase["blocks"]: + blockheader = block["blockHeader"] - filename = os.path.join(folder, filename) - fp = open(filename) - testcase = dict(json.loads(fp.read())) - fp.close() - for name, testcase in testcase.items(): - output += ( - gen_test(testcase, filename, symbolic=symbolic, skip="Performance" in filename) - + "\n" - ) - cnt += 1 + body += f""" + # Start a block + self.assertEqual(m.count_all_states(), 1) + m.start_block(blocknumber={blockheader['number']}, + timestamp={blockheader['timestamp']}, + difficulty={blockheader['difficulty']}, + coinbase={blockheader['coinbase']}, + gaslimit={hex(int(blockheader['gasLimit'],0))}) - print(f"Generated {cnt} testcases from jsons in {folder}.", file=sys.stderr) - else: - folder = None - filename = os.path.abspath(filename_or_folder) - fp = open(filename) - testcase = dict(json.loads(fp.read())) - fp.close() - for name, testcase in testcase.items(): - output += ( - gen_test(testcase, filename, symbolic=symbolic, skip="Performance" in filename) - + "\n" + #VMtest Transaction +""" + + for transaction in block["transactions"]: + address = None if transaction["to"] == "" else int(transaction["to"], 16) + calldata = unhexlify(transaction["data"][2:]) + gas = int(transaction["gasLimit"], 0) + price = int(transaction["gasPrice"], 0) + nonce = int(transaction["nonce"], 0) + value = 0 if transaction["value"] == "0x" else int(transaction["value"], 0) + r = int(transaction["r"], 0) + s = int(transaction["s"], 0) + v = int(transaction["v"], 0) + caller = get_caller(nonce, price, gas, address, value, calldata, v, r, s) + body += f""" + + m.transaction(caller={hex(caller)}, + address={hex(address)}, + value={value}, + data={calldata}, + gas={gas}, + price={price})""" + + body += f""" + for state in m.all_states: + world = state.platform + self.assertEqual(used_gas_plugin.used_gas, {blockheader['gasUsed']}) + + world.end_block()""" + + for account_address, account in testcase["postState"].items(): + body += f""" + # Add post checks for account {account_address} + # check nonce, balance, code and storage values + self.assertEqual(world.get_nonce({account_address}), {account['nonce']}) + self.assertEqual(world.get_balance({account_address}), {account['balance']}) + self.assertEqual(world.get_code({account_address}), {"unhexlify('"+account['code'][2:]+"')" if account['code'][2:] else "b''"})""" + + if account["storage"]: + body += """ + # check storage""" + + for key, value in account["storage"].items(): + body += f""" + self.assertEqual(world.get_storage_data({account_address}, {key}), {value})""" + + if "logs" in testcase: + print(testcase["logs"]) + body += f""" + # check logs + logs = [Log(unhexlify('{'{'}:040x{'}'}'.format(l.address)), l.topics, solve(l.memlog)) for l in world.logs] + data = rlp.encode(logs) + self.assertEqual(sha3.keccak_256(data).hexdigest(), '{testcase['logs'][2:]}')""" + + return body + + +def gen_testfile(testcases, fork): + global total_count + output = gen_header(testcases) + for name, testcase in testcases.items(): + if testcase["network"] != fork: + logging.warning( + f"Skipping testcase {name}. Wrong fork: {testcase['network']} != {fork}" ) + continue + total_count += 1 + output += gen_body(name.replace("-", "_"), testcase) + output += gen_footer(testcases) + return output - output += """ -if __name__ == '__main__': - unittest.main() -""" - postfix = "symbolic" if symbolic else "concrete" - - if folder: - testname = folder.split("/")[-1] - with open(f"ethereum_vm/VMTests_{postfix}/test_{testname}.py", "w") as f: - f.write(output) - with open(f"ethereum_vm/VMTests_{postfix}/__init__.py", "w") as f: - f.write("# DO NOT DELETE") - print("Tests generated. If this is the only output, u did sth bad.", file=sys.stderr) - else: - print(output) +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Manticore test generator for Ethereum BlockchainTests" + ) + parser.add_argument( + "-v", action="count", default=0, help="Specify verbosity level from -v to -vvvv" + ) + parser.add_argument( + "-f", + "--fork", + "--flavor", + default=DEFAULT_FORK, + type=str, + help="Fork, default: byzantium. Possible: Byzantium, Constantinople, EIP150, EIP158, Frontier, Homestead, Istanbul." + "Also an unsigned block number is accepted to select the fork.", + ) + + parser.add_argument( + "-d", "--dry-run", default=False, action="store_true", help="Do not generate any file" + ) + + parser.add_argument( + "-i", "--input-path", nargs="?", help="Path to Ethereum tests", required=True + ) + parser.add_argument("-r", "--filter-regex", type=str, help="Filter by regex") + parser.add_argument( + "-o", + "--output-path", + nargs="?", + default="!inplace", + help="Output path, by default this generates a .py file in the same folder as the json input", + ) + parser.add_argument( + "-x", "--force", default=False, action="store_true", help="Overwrite any existing file" + ) + args = parser.parse_args(sys.argv[1:]) + + # logging + loglevel = (logging.CRITICAL, logging.ERROR, logging.INFO, logging.DEBUG) + logging.basicConfig(level=loglevel[min(args.v, 3)], format="%(message)s") + + # Forks + accepted_forks = [ + "Byzantium", + "Constantinople", + "EIP150", + "EIP158", + "Frontier", + "Homestead", + "Istanbul", + ] + args.fork = args.fork.title() + + if args.fork not in accepted_forks: + logging.error("Wrong fork name. Please provide one of %s.\n" % accepted_forks) + sys.exit(1) + + # Dry run + if args.dry_run: + open = fake_open + + # input path + if not os.path.isfile(args.input_path): + logging.error("Wrong json test file (%s). Please provide one.\n" % args.input_path) + sys.exit(1) + + with open(args.input_path) as fp: + if not os.path.isfile(args.input_path) or not args.input_path.endswith(".json"): + logging.debug("Input file args.input_path looks odd. Expecting a .json file.") + testcases = dict(json.loads(fp.read())) + + logging.info(f"Loaded {len(testcases)} testcases from {args.input_path}") + + # output path + if args.output_path == "!inplace": + # /xxx/yyy/testfile.json -> ./testfile.py + stem, ext = os.path.splitext(args.input_path) + args.output_path = stem + ".py" + elif os.path.isdir(args.output_path): + # /xxx/yyy/testfile.json -> $output_path/yyy_testfile.py + stem, ext = os.path.splitext(os.path.basename(args.input_path)) + output_path = os.path.join(args.output_path, f"test_{stem}.py") + # If output pats collides add the containing folder to the name + if os.path.exists(output_path): + folders = args.input_path.split(os.sep) + if len(folders) >= 2: + output_path = os.path.join(args.output_path, f"test_{folders[-2]}_{stem}.py") + args.output_path = output_path + # or else /xxx/yyy/testfile.json -> $whatever + + if os.path.exists(args.output_path): + if not args.force: + logging.error(f"File {args.output_path} already exists. Consider adding --force") + if not args.dry_run: + sys.exit(1) + logging.error(f"Continuing because it is a dry run. ") + else: + logging.info(f"File {args.output_path} already exists. Overwritting.") + + with open(args.output_path, "w") as fp: + fp.write(gen_testfile(testcases, args.fork)) + + logging.info(f"{total_count} unittests generated in {args.output_path}") diff --git a/tests/ethereum/EVM/__init__.py b/tests/ethereum/EVM/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/tests/ethereum/EVM/test_EVMADD.py b/tests/ethereum/EVM/test_EVMADD.py deleted file mode 100644 index e80e242a1..000000000 --- a/tests/ethereum/EVM/test_EVMADD.py +++ /dev/null @@ -1,2007 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_ADD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_ADD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_ADD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_ADD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819951], - ) - - def test_ADD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301262], - ) - - def test_ADD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718911]) - - def test_ADD_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_ADD_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADD_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADD_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_ADD_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADD_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADD_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADD_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADD_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADD_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADD_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADD_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADD_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_ADD_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_ADD_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADD_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADD_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADD_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADD_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819951], - ) - - def test_ADD_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_ADD_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_ADD_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_ADD_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [61514547407324228818772085785865451047049679353621549645961841504203850121215], - ) - - def test_ADD_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819968], - ) - - def test_ADD_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_ADD_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820000], - ) - - def test_ADD_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504350043516790537761646130706531776516538464538864], - ) - - def test_ADD_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301262], - ) - - def test_ADD_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADD_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_ADD_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [61514547407324228818772085785865451047049679353621549645961841504203850121215], - ) - - def test_ADD_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [7237005577332262213973186563042994240829374041602535252466099000494570602526], - ) - - def test_ADD_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_ADD_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_ADD_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_ADD_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_ADD_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADD_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADD_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADD_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819968], - ) - - def test_ADD_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_ADD_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADD_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADD_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADD_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADD_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADD_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADD_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADD_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_ADD_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_ADD_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADD_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADD_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADD_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADD_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADD_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADD_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADD_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820000], - ) - - def test_ADD_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_ADD_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADD_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADD_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [96]) - - def test_ADD_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADD_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718911]) - - def test_ADD_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADD_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADD_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504350043516790537761646130706531776516538464538864], - ) - - def test_ADD_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_ADD_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADD_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADD_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADD_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x01" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMADDMOD.py b/tests/ethereum/EVM/test_EVMADDMOD.py deleted file mode 100644 index 23c6f5ec8..000000000 --- a/tests/ethereum/EVM/test_EVMADDMOD.py +++ /dev/null @@ -1,17766 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_ADDMOD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_ADDMOD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_ADDMOD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_ADDMOD_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_ADDMOD_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_ADDMOD_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADDMOD_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_ADDMOD_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_ADDMOD_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_ADDMOD_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_ADDMOD_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [61514547407324228818772085785865451047049679353621549645961841504203850121215], - ) - - def test_ADDMOD_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819968], - ) - - def test_ADDMOD_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_ADDMOD_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820000], - ) - - def test_ADDMOD_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504350043516790537761646130706531776516538464538864], - ) - - def test_ADDMOD_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_ADDMOD_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [61514547407324228818772085785865451047049679353621549645961841504203850121215], - ) - - def test_ADDMOD_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [7237005577332262213973186563042994240829374041602535252466099000494570602526], - ) - - def test_ADDMOD_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_ADDMOD_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_ADDMOD_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_ADDMOD_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_ADDMOD_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819968], - ) - - def test_ADDMOD_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_ADDMOD_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADDMOD_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_ADDMOD_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_ADDMOD_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADDMOD_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820000], - ) - - def test_ADDMOD_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_ADDMOD_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [96]) - - def test_ADDMOD_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADDMOD_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADDMOD_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504350043516790537761646130706531776516538464538864], - ) - - def test_ADDMOD_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_ADDMOD_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADDMOD_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADDMOD_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADDMOD_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824]) - - def test_ADDMOD_82(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_83(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_84(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_85(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_86(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_87(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_88(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_89(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_90(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_91(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_92(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_93(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_94(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_95(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_96(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_97(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_98(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_99(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_100(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_101(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_102(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_103(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_104(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_105(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_106(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_107(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_108(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_109(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_110(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_111(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_112(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_113(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_114(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_115(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_116(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_117(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_118(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_119(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_120(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_121(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_122(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_123(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_124(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_125(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_126(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_127(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_128(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_129(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_130(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_131(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_132(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_133(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_134(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_135(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_136(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_137(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_138(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_139(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_140(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_141(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_142(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_143(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_144(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_145(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_146(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_147(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_148(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_149(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_150(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_151(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_152(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_153(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_154(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_155(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_156(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_157(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_158(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_159(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_160(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_161(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_162(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_163(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_164(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_165(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_166(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_167(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_168(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_169(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_170(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_171(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_172(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_173(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_174(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_175(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_176(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_177(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_178(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_179(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_180(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_181(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_182(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_183(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_184(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_185(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_186(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_187(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_188(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_189(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_190(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_191(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_192(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_193(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_194(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_195(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_196(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_197(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_198(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_199(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_200(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_201(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_202(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_203(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_204(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_205(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_206(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_207(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_208(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_209(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_210(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_211(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_212(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_213(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_214(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_215(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_216(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_217(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_218(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_219(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_220(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_221(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_222(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_223(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_224(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_225(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_226(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_227(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_228(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_229(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_230(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_231(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_232(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_233(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_234(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_235(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_236(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_237(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_238(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_239(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_240(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_241(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_242(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_243(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_244(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [62]) - - def test_ADDMOD_245(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_246(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_247(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_248(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301294], - ) - - def test_ADDMOD_249(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_250(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [63]) - - def test_ADDMOD_251(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [79]) - - def test_ADDMOD_252(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718943]) - - def test_ADDMOD_253(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_254(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_255(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_256(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_257(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_258(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_259(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_260(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_261(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_262(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_263(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_264(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_265(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_266(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_ADDMOD_267(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_268(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_269(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_270(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADDMOD_271(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_272(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_273(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_274(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_275(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_276(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_277(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_278(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_279(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_280(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301294], - ) - - def test_ADDMOD_281(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_282(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_ADDMOD_283(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_ADDMOD_284(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [7237005577332262213973186563042994240829374041602535252466099000494570602526], - ) - - def test_ADDMOD_285(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_ADDMOD_286(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_ADDMOD_287(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_ADDMOD_288(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_ADDMOD_289(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_290(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_291(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_292(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_293(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_ADDMOD_294(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_295(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_296(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_297(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADDMOD_298(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [63]) - - def test_ADDMOD_299(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_300(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_301(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_302(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_ADDMOD_303(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_304(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_305(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_306(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADDMOD_307(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [79]) - - def test_ADDMOD_308(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_309(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_310(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_311(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_ADDMOD_312(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_313(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_314(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [96]) - - def test_ADDMOD_315(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADDMOD_316(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718943]) - - def test_ADDMOD_317(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_318(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADDMOD_319(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_320(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_ADDMOD_321(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADDMOD_322(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADDMOD_323(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADDMOD_324(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824]) - - def test_ADDMOD_325(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300301], - ) - - def test_ADDMOD_326(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_ADDMOD_327(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300783], - ) - - def test_ADDMOD_328(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300526], - ) - - def test_ADDMOD_329(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_ADDMOD_330(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300798], - ) - - def test_ADDMOD_331(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300814], - ) - - def test_ADDMOD_332(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300830], - ) - - def test_ADDMOD_333(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718431]) - - def test_ADDMOD_334(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_ADDMOD_335(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_336(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_337(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_ADDMOD_338(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_339(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_340(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_341(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_342(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_343(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300783], - ) - - def test_ADDMOD_344(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_345(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_346(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301008], - ) - - def test_ADDMOD_347(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_348(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_349(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_350(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_351(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADDMOD_352(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300526], - ) - - def test_ADDMOD_353(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_ADDMOD_354(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301008], - ) - - def test_ADDMOD_355(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300751], - ) - - def test_ADDMOD_356(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_ADDMOD_357(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301023], - ) - - def test_ADDMOD_358(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301039], - ) - - def test_ADDMOD_359(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301055], - ) - - def test_ADDMOD_360(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718656]) - - def test_ADDMOD_361(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_ADDMOD_362(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_363(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_364(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_ADDMOD_365(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_366(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_367(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_368(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_369(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_370(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300798], - ) - - def test_ADDMOD_371(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_372(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_373(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301023], - ) - - def test_ADDMOD_374(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_375(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_376(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_377(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_378(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADDMOD_379(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300814], - ) - - def test_ADDMOD_380(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_381(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_382(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301039], - ) - - def test_ADDMOD_383(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_384(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_385(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_386(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_387(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADDMOD_388(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300830], - ) - - def test_ADDMOD_389(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_390(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_391(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301055], - ) - - def test_ADDMOD_392(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_393(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_394(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_395(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [96]) - - def test_ADDMOD_396(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADDMOD_397(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718431]) - - def test_ADDMOD_398(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_399(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_ADDMOD_400(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718656]) - - def test_ADDMOD_401(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_ADDMOD_402(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_ADDMOD_403(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_ADDMOD_404(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_ADDMOD_405(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824]) - - def test_ADDMOD_406(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_407(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_408(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_409(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_410(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_411(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_412(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_413(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_414(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_415(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_416(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_417(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_418(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_419(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_420(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_421(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_422(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_423(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_424(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_425(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_426(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_427(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_428(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_429(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_430(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_431(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_432(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_433(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_434(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_435(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_436(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_437(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_438(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_439(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_440(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_441(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_442(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_443(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_444(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_445(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_446(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_447(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_448(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_449(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_450(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_451(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_452(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_453(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_454(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_455(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_456(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_457(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_458(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_459(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_460(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_461(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_462(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_463(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_464(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_465(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_466(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_467(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_468(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_469(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_470(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_471(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_472(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_473(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_474(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_475(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_476(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_477(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_478(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_479(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_480(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_481(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_482(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_483(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_484(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_485(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_486(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_487(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [30]) - - def test_ADDMOD_488(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_489(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_490(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_491(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_492(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_493(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_494(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_495(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_496(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_497(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_498(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_499(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_500(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_501(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_502(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_503(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_504(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_505(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_506(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_507(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_508(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_509(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_510(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_511(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_512(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_513(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_514(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_515(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_516(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_517(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_518(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_519(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_520(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_521(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_522(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_523(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_524(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_525(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_526(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_527(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [30]) - - def test_ADDMOD_528(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_529(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_530(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_531(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_532(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_533(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_534(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_535(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_536(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_537(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_538(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_539(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_540(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_541(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_542(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_543(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_544(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_545(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_546(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_547(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_548(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_549(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_550(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_551(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_552(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_553(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_554(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_555(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_556(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_557(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_558(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_559(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_560(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_561(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_562(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_563(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_564(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_565(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_566(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_567(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_568(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [30]) - - def test_ADDMOD_569(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_570(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_571(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_572(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_573(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_574(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_575(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_576(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_577(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_578(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_579(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_580(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_581(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_582(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_583(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_584(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_585(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_586(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_587(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_588(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_589(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_590(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_591(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_592(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_593(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_594(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_595(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_596(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_597(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_598(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_599(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_600(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_601(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_602(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_603(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_604(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [14]) - - def test_ADDMOD_605(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_606(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_607(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_608(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [46]) - - def test_ADDMOD_609(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_610(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_611(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_612(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_613(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_614(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_615(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_616(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_617(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_618(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_619(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_620(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_621(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_622(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_623(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_624(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_625(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_626(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_627(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_628(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_629(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_630(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_631(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_632(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_633(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_634(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_635(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_ADDMOD_636(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_637(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_638(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_639(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_640(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_ADDMOD_641(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_642(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_643(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_644(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_ADDMOD_645(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_646(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_647(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_648(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_649(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [649037107316853453566312041152510]) - - def test_ADDMOD_650(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_ADDMOD_651(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576256]) - - def test_ADDMOD_652(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [486777830487640090174734030864367]) - - def test_ADDMOD_653(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [334659758460252561995129646219278]) - - def test_ADDMOD_654(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576271]) - - def test_ADDMOD_655(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576287]) - - def test_ADDMOD_656(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576303]) - - def test_ADDMOD_657(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_ADDMOD_658(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_ADDMOD_659(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_660(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_661(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_ADDMOD_662(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_ADDMOD_663(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_664(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_665(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_666(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_667(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576256]) - - def test_ADDMOD_668(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_669(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_ADDMOD_670(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288113]) - - def test_ADDMOD_671(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643024]) - - def test_ADDMOD_672(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_673(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_674(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_675(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_676(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [486777830487640090174734030864367]) - - def test_ADDMOD_677(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_ADDMOD_678(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288113]) - - def test_ADDMOD_679(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576224]) - - def test_ADDMOD_680(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [172400481631039198603551635931135]) - - def test_ADDMOD_681(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288128]) - - def test_ADDMOD_682(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288144]) - - def test_ADDMOD_683(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288160]) - - def test_ADDMOD_684(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_ADDMOD_685(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [334659758460252561995129646219278]) - - def test_ADDMOD_686(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_ADDMOD_687(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643024]) - - def test_ADDMOD_688(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [172400481631039198603551635931135]) - - def test_ADDMOD_689(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [20282409603651670423947251286046]) - - def test_ADDMOD_690(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643039]) - - def test_ADDMOD_691(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643055]) - - def test_ADDMOD_692(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643071]) - - def test_ADDMOD_693(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_ADDMOD_694(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576271]) - - def test_ADDMOD_695(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_696(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_ADDMOD_697(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288128]) - - def test_ADDMOD_698(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643039]) - - def test_ADDMOD_699(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_700(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_701(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_702(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_703(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576287]) - - def test_ADDMOD_704(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_705(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_ADDMOD_706(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288144]) - - def test_ADDMOD_707(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643055]) - - def test_ADDMOD_708(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_709(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_710(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_711(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_712(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576303]) - - def test_ADDMOD_713(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_714(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_ADDMOD_715(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288160]) - - def test_ADDMOD_716(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643071]) - - def test_ADDMOD_717(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [64]) - - def test_ADDMOD_718(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [80]) - - def test_ADDMOD_719(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [96]) - - def test_ADDMOD_720(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_721(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_ADDMOD_722(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ADDMOD_723(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ADDMOD_724(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_ADDMOD_725(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_ADDMOD_726(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_ADDMOD_727(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_ADDMOD_728(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_ADDMOD_729(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x08" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMADDRESS.py b/tests/ethereum/EVM/test_EVMADDRESS.py deleted file mode 100644 index a98e1b20f..000000000 --- a/tests/ethereum/EVM/test_EVMADDRESS.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_ADDRESS(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_ADDRESS_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"0" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMAND.py b/tests/ethereum/EVM/test_EVMAND.py deleted file mode 100644 index 064dfb2d5..000000000 --- a/tests/ethereum/EVM/test_EVMAND.py +++ /dev/null @@ -1,1929 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_AND(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_AND_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_AND_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_AND_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_AND_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_AND_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_AND_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_AND_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_AND_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_AND_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_AND_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_AND_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_AND_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301248], - ) - - def test_AND_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_AND_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_AND_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_AND_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_AND_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301248], - ) - - def test_AND_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_AND_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_AND_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_AND_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_AND_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_AND_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_AND_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_AND_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_AND_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_AND_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x16" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMBALANCE.py b/tests/ethereum/EVM/test_EVMBALANCE.py deleted file mode 100644 index 186351c51..000000000 --- a/tests/ethereum/EVM/test_EVMBALANCE.py +++ /dev/null @@ -1,291 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_BALANCE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_BALANCE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x0 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x1 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0xF - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x10 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x20 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BALANCE_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x111111111111111111111111111111111111100 - balance = 1048576 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"1" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1048576]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMBYTE.py b/tests/ethereum/EVM/test_EVMBYTE.py deleted file mode 100644 index f76624618..000000000 --- a/tests/ethereum/EVM/test_EVMBYTE.py +++ /dev/null @@ -1,1902 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_BYTE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_BYTE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [255]) - - def test_BYTE_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [255]) - - def test_BYTE_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [255]) - - def test_BYTE_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [127]) - - def test_BYTE_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [255]) - - def test_BYTE_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [255]) - - def test_BYTE_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [8]) - - def test_BYTE_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_BYTE_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_BYTE_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x1a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCALLCODE.py b/tests/ethereum/EVM/test_EVMCALLCODE.py deleted file mode 100644 index 5071ddd80..000000000 --- a/tests/ethereum/EVM/test_EVMCALLCODE.py +++ /dev/null @@ -1,333 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_CALLCODE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - - try: - new_vm.execute() - except evm.StartTx: - pass - new_vm.execute() - - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_CALLCODE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - def test_CALLCODE_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xf2" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INSUFFICIENT STACK") - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCALLDATALOAD.py b/tests/ethereum/EVM/test_EVMCALLDATALOAD.py deleted file mode 100644 index 6a1eee0a0..000000000 --- a/tests/ethereum/EVM/test_EVMCALLDATALOAD.py +++ /dev/null @@ -1,247 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -from manticore.core.smtlib import simplify, to_constant -import os - - -class EVMTest_CALLDATALOAD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_CALLDATALOAD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_CALLDATALOAD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertSequenceEqual( - list(map(to_constant, new_vm.stack)), - [29515630589904128245223976570842015727304113738300535931626442982409229107200], - ) - - def test_CALLDATALOAD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertSequenceEqual( - list(map(to_constant, new_vm.stack)), - [29515630589904128245223976570842015727304113738300535931626442982409224847360], - ) - - def test_CALLDATALOAD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_CALLDATALOAD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_CALLDATALOAD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - list(map(to_constant, new_vm.stack)), - [29515630589904128245223976570842010042800435681475029265659040150473943285760], - ) - - def test_CALLDATALOAD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_CALLDATALOAD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_CALLDATALOAD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"5" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCALLDATASIZE.py b/tests/ethereum/EVM/test_EVMCALLDATASIZE.py deleted file mode 100644 index cdcdfffb1..000000000 --- a/tests/ethereum/EVM/test_EVMCALLDATASIZE.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_CALLDATASIZE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_CALLDATASIZE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"6" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [30]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCALLER.py b/tests/ethereum/EVM/test_EVMCALLER.py deleted file mode 100644 index c1858da2f..000000000 --- a/tests/ethereum/EVM/test_EVMCALLER.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_CALLER(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_CALLER_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"3" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCALLVALUE.py b/tests/ethereum/EVM/test_EVMCALLVALUE.py deleted file mode 100644 index 44f0a8c34..000000000 --- a/tests/ethereum/EVM/test_EVMCALLVALUE.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_CALLVALUE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_CALLVALUE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"4" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10000]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCODESIZE.py b/tests/ethereum/EVM/test_EVMCODESIZE.py deleted file mode 100644 index 1d022704d..000000000 --- a/tests/ethereum/EVM/test_EVMCODESIZE.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_CODESIZE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_CODESIZE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"8" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMCOINBASE.py b/tests/ethereum/EVM/test_EVMCOINBASE.py deleted file mode 100644 index 620daa454..000000000 --- a/tests/ethereum/EVM/test_EVMCOINBASE.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_COINBASE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_COINBASE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"A" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMDIFFICULTY.py b/tests/ethereum/EVM/test_EVMDIFFICULTY.py deleted file mode 100644 index b619223a7..000000000 --- a/tests/ethereum/EVM/test_EVMDIFFICULTY.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_DIFFICULTY(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_DIFFICULTY_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"D" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMDIV.py b/tests/ethereum/EVM/test_EVMDIV.py deleted file mode 100644 index 06f224c51..000000000 --- a/tests/ethereum/EVM/test_EVMDIV.py +++ /dev/null @@ -1,1938 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_DIV(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_DIV_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_DIV_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_DIV_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_DIV_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_DIV_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_DIV_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_DIV_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_DIV_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_DIV_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_DIV_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_DIV_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [7237005577332262213973186563042994240829374041602535252466099000494570602495], - ) - - def test_DIV_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301247], - ) - - def test_DIV_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [226156424291633194186662080095093570025917938800079226639565593765455331328], - ) - - def test_DIV_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_DIV_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [3]) - - def test_DIV_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [380599384721589301615542925186532036368732432]) - - def test_DIV_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301247], - ) - - def test_DIV_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1809251394333065553493296640760748560207343510400633813116524750123642650623], - ) - - def test_DIV_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [113078212145816597093331040047546785012958969400039613319782796882727665664], - ) - - def test_DIV_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [190299692360794650807771462593266018184366216]) - - def test_DIV_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [2412335192444087404657728854347664746943124680534178417488699666831523534165], - ) - - def test_DIV_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1206167596222043702328864427173832373471562340267089208744349833415761767082], - ) - - def test_DIV_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [75385474763877731395554026698364523341972646266693075546521864588485110442], - ) - - def test_DIV_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_DIV_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [126866461573863100538514308395510678789577477]) - - def test_DIV_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [19014759003423441022450548080640]) - - def test_DIV_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [9507379501711720511225274040320]) - - def test_DIV_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [594211218856982531951579627520]) - - def test_DIV_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_DIV_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x04" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMDUP.py b/tests/ethereum/EVM/test_EVMDUP.py deleted file mode 100644 index 296f2fb57..000000000 --- a/tests/ethereum/EVM/test_EVMDUP.py +++ /dev/null @@ -1,411 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_DUP(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_DUP_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ], - ) - - def test_DUP_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0, 0]) - - def test_DUP_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1, 1]) - - def test_DUP_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 57896044618658097711785492504343953926634992332820282019728792003956564819952, - 57896044618658097711785492504343953926634992332820282019728792003956564819952, - ], - ) - - def test_DUP_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 3618502788666131106986593281521497120414687020801267626233049500247285301263, - 3618502788666131106986593281521497120414687020801267626233049500247285301263, - ], - ) - - def test_DUP_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16, 16]) - - def test_DUP_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32, 32]) - - def test_DUP_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48, 48]) - - def test_DUP_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x80" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 6089590155545428825848686802984512581899718912, - 6089590155545428825848686802984512581899718912, - ], - ) - - def test_DUP_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x81" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ], - ) - - def test_DUP_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x81" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 0, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ], - ) - - def test_DUP_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x81" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 1, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ], - ) - - def test_DUP_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x81" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 57896044618658097711785492504343953926634992332820282019728792003956564819952, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ], - ) - - def test_DUP_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x81" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [ - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - 3618502788666131106986593281521497120414687020801267626233049500247285301263, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ], - ) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMEQ.py b/tests/ethereum/EVM/test_EVMEQ.py deleted file mode 100644 index d7c289cc6..000000000 --- a/tests/ethereum/EVM/test_EVMEQ.py +++ /dev/null @@ -1,1902 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_EQ(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_EQ_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EQ_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EQ_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x14" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMEXP.py b/tests/ethereum/EVM/test_EVMEXP.py deleted file mode 100644 index 8e70aaffb..000000000 --- a/tests/ethereum/EVM/test_EVMEXP.py +++ /dev/null @@ -1,1944 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_EXP(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_EXP_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_EXP_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [104454113832828984621679659393253883542637298667129925477260695573804969029359], - ) - - def test_EXP_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_EXP_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_EXP_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_EXP_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_EXP_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_EXP_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_EXP_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_EXP_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [97153515582439856940218076430383148080316642374323115531717460774015781538049], - ) - - def test_EXP_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_EXP_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224972401556225198063], - ) - - def test_EXP_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [18446744073709551616]) - - def test_EXP_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019735360412312277710593], - ) - - def test_EXP_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [18446744073709551616]) - - def test_EXP_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1208925819614629174706176]) - - def test_EXP_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [794071845499378503449051136]) - - def test_EXP_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [8303694420805298775410959586403913600201715917447438497573206049841934761984], - ) - - def test_EXP_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [340282366920938463463374607431768211456]) - - def test_EXP_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [43143988327398919500410556793212890625]) - - def test_EXP_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [340282366920938463463374607431768211456]) - - def test_EXP_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1461501637330902918203684832716283019655932542976]) - - def test_EXP_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [630550095814788844423632687832745817333905738742890496]) - - def test_EXP_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6277101735386680763835789423207666416102355444464034512896]) - - def test_EXP_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097712068879837772420409703173580337995947392654709187277710593], - ) - - def test_EXP_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6277101735386680763835789423207666416102355444464034512896]) - - def test_EXP_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1766847064778384329583297500742918515827483896875618958121606201292619776], - ) - - def test_EXP_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [17084401304090163016086072004374689170541683170424114643147834605304589320192], - ) - - def test_EXP_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_EXP_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [42192513242301740010671492996252704544191162524312342410321251717326910681089], - ) - - def test_EXP_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXP_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMEXTCODESIZE.py b/tests/ethereum/EVM/test_EVMEXTCODESIZE.py deleted file mode 100644 index 3ae578e74..000000000 --- a/tests/ethereum/EVM/test_EVMEXTCODESIZE.py +++ /dev/null @@ -1,291 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_EXTCODESIZE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_EXTCODESIZE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x66666666666666666666666666666666666666 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3030303030303030303030303030303030303030 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30303030303030303030303030303030303030 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x66666666666666666666666666666666666666 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30303030303030303030303030303030303030 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30303030303030303030303030303030303030 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30303030303030303030303030303030303030 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30303030303030303030303030303030303030 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_EXTCODESIZE_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x30313131313131313131313131313131313131 - balance = None - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b";" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMGAS.py b/tests/ethereum/EVM/test_EVMGAS.py deleted file mode 100644 index fad076ad0..000000000 --- a/tests/ethereum/EVM/test_EVMGAS.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_GAS(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_GAS_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"Z" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [999998]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMGASLIMIT.py b/tests/ethereum/EVM/test_EVMGASLIMIT.py deleted file mode 100644 index b8ca3d881..000000000 --- a/tests/ethereum/EVM/test_EVMGASLIMIT.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_GASLIMIT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_GASLIMIT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"E" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMGASPRICE.py b/tests/ethereum/EVM/test_EVMGASPRICE.py deleted file mode 100644 index 866fbed10..000000000 --- a/tests/ethereum/EVM/test_EVMGASPRICE.py +++ /dev/null @@ -1,58 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_GASPRICE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_GASPRICE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - owner_account = world.create_account(balance=1000) - contract_account = world.create_account(balance=1000, code=b":") - - world._open_transaction("CALL", contract_account, 10, "", owner_account, 0) - world._open_transaction("CALL", contract_account, 100, "", owner_account, 0) - world._open_transaction("CALL", contract_account, 100, "", owner_account, 0) - - new_vm = world.current_vm - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMGETPC.py b/tests/ethereum/EVM/test_EVMGETPC.py deleted file mode 100644 index 9686b9186..000000000 --- a/tests/ethereum/EVM/test_EVMGETPC.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_GETPC(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_GETPC_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"X" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMGT.py b/tests/ethereum/EVM/test_EVMGT.py deleted file mode 100644 index 1348967fd..000000000 --- a/tests/ethereum/EVM/test_EVMGT.py +++ /dev/null @@ -1,1902 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_GT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_GT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_GT_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_GT_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x11" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMINVALID.py b/tests/ethereum/EVM/test_EVMINVALID.py deleted file mode 100644 index c59c81bb2..000000000 --- a/tests/ethereum/EVM/test_EVMINVALID.py +++ /dev/null @@ -1,59 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_INVALID(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_INVALID_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfe" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "INVALID") - self.assertEqual(new_vm.gas, 1000000) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMISZERO.py b/tests/ethereum/EVM/test_EVMISZERO.py deleted file mode 100644 index fd7a57346..000000000 --- a/tests/ethereum/EVM/test_EVMISZERO.py +++ /dev/null @@ -1,237 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_ISZERO(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_ISZERO_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_ISZERO_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_ISZERO_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x15" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMJUMP.py b/tests/ethereum/EVM/test_EVMJUMP.py deleted file mode 100644 index 844f1e09b..000000000 --- a/tests/ethereum/EVM/test_EVMJUMP.py +++ /dev/null @@ -1,244 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_JUMP(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_JUMP_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual( - new_vm.pc, - 115792089237316195423570985008687907853269984665640564039457584007913129639935, - ) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 0) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual( - new_vm.pc, 57896044618658097711785492504343953926634992332820282019728792003956564819952 - ) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual( - new_vm.pc, 3618502788666131106986593281521497120414687020801267626233049500247285301263 - ) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 16) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 32) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 48) - self.assertEqual(new_vm.stack, []) - - def test_JUMP_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"V" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 6089590155545428825848686802984512581899718912) - self.assertEqual(new_vm.stack, []) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMJUMPDEST.py b/tests/ethereum/EVM/test_EVMJUMPDEST.py deleted file mode 100644 index 8b954a99b..000000000 --- a/tests/ethereum/EVM/test_EVMJUMPDEST.py +++ /dev/null @@ -1,60 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_JUMPDEST(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_JUMPDEST_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"[" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMLT.py b/tests/ethereum/EVM/test_EVMLT.py deleted file mode 100644 index cb24f61b5..000000000 --- a/tests/ethereum/EVM/test_EVMLT.py +++ /dev/null @@ -1,1902 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_LT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_LT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_LT_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_LT_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x10" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMMOD.py b/tests/ethereum/EVM/test_EVMMOD.py deleted file mode 100644 index 2d48ffeb3..000000000 --- a/tests/ethereum/EVM/test_EVMMOD.py +++ /dev/null @@ -1,1917 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_MOD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_MOD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_MOD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MOD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MOD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MOD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MOD_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_MOD_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MOD_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MOD_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MOD_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MOD_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_MOD_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_MOD_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MOD_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MOD_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MOD_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MOD_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MOD_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_MOD_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MOD_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MOD_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_MOD_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MOD_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_MOD_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MOD_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MOD_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_MOD_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_MOD_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MOD_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MOD_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MOD_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x06" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMMSIZE.py b/tests/ethereum/EVM/test_EVMMSIZE.py deleted file mode 100644 index fb54a0208..000000000 --- a/tests/ethereum/EVM/test_EVMMSIZE.py +++ /dev/null @@ -1,61 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_MSIZE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_MSIZE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"Y" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm.MSTORE8(124, 0x41) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [128]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMMSTORE8.py b/tests/ethereum/EVM/test_EVMMSTORE8.py deleted file mode 100644 index 713c1fe31..000000000 --- a/tests/ethereum/EVM/test_EVMMSTORE8.py +++ /dev/null @@ -1,1885 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os -from manticore.utils import config - -consts = config.get_group("evm") - - -class EVMTest_MSTORE8(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def setUp(self): - self.saved_gas_config = consts.oog - consts.oog = "complete" - - def tearDown(self): - consts.oog = self.saved_gas_config - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_MSTORE8_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 255) - - def test_MSTORE8_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 255) - - def test_MSTORE8_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 255) - - def test_MSTORE8_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 255) - - def test_MSTORE8_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 255) - - def test_MSTORE8_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 0) - - def test_MSTORE8_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 0) - - def test_MSTORE8_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 0) - - def test_MSTORE8_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 0) - - def test_MSTORE8_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 0) - - def test_MSTORE8_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 1) - - def test_MSTORE8_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 1) - - def test_MSTORE8_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 1) - - def test_MSTORE8_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 1) - - def test_MSTORE8_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 1) - - def test_MSTORE8_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 240) - - def test_MSTORE8_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 240) - - def test_MSTORE8_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 240) - - def test_MSTORE8_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 240) - - def test_MSTORE8_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 240) - - def test_MSTORE8_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 15) - - def test_MSTORE8_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 15) - - def test_MSTORE8_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 15) - - def test_MSTORE8_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 15) - - def test_MSTORE8_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 15) - - def test_MSTORE8_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 16) - - def test_MSTORE8_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 16) - - def test_MSTORE8_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 16) - - def test_MSTORE8_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 16) - - def test_MSTORE8_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 16) - - def test_MSTORE8_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 32) - - def test_MSTORE8_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 32) - - def test_MSTORE8_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 32) - - def test_MSTORE8_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 32) - - def test_MSTORE8_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 32) - - def test_MSTORE8_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 48) - - def test_MSTORE8_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 48) - - def test_MSTORE8_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 48) - - def test_MSTORE8_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 48) - - def test_MSTORE8_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 48) - - def test_MSTORE8_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(0), 0) - - def test_MSTORE8_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(1), 0) - - def test_MSTORE8_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_MSTORE8_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(16), 0) - - def test_MSTORE8_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(32), 0) - - def test_MSTORE8_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - self.assertEqual(new_vm._load(48), 0) - - def test_MSTORE8_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"S" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMMUL.py b/tests/ethereum/EVM/test_EVMMUL.py deleted file mode 100644 index 4777b2be0..000000000 --- a/tests/ethereum/EVM/test_EVMMUL.py +++ /dev/null @@ -1,2004 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_MUL(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_MUL_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MUL_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_MUL_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_MUL_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338673], - ) - - def test_MUL_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_MUL_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_MUL_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639888], - ) - - def test_MUL_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921024], - ) - - def test_MUL_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_MUL_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MUL_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_MUL_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MUL_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MUL_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MUL_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MUL_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MUL_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_MUL_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_MUL_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MUL_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639696], - ) - - def test_MUL_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639680], - ) - - def test_MUL_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639424], - ) - - def test_MUL_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639168], - ) - - def test_MUL_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008590474410781257804426985050609831806602734137344], - ) - - def test_MUL_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338673], - ) - - def test_MUL_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MUL_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639696], - ) - - def test_MUL_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [108555083659983933209597798445644913612440610624038028786991485007418559037665], - ) - - def test_MUL_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820208], - ) - - def test_MUL_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [480]) - - def test_MUL_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820688], - ) - - def test_MUL_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [91343852333181432387730302044767688728495783680]) - - def test_MUL_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_MUL_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MUL_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639680], - ) - - def test_MUL_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820208], - ) - - def test_MUL_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MUL_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MUL_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MUL_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MUL_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_MUL_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MUL_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639424], - ) - - def test_MUL_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [480]) - - def test_MUL_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MUL_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1024]) - - def test_MUL_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MUL_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MUL_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639888], - ) - - def test_MUL_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MUL_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639168], - ) - - def test_MUL_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820688], - ) - - def test_MUL_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MUL_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MUL_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2304]) - - def test_MUL_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MUL_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921024], - ) - - def test_MUL_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MUL_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MUL_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008590474410781257804426985050609831806602734137344], - ) - - def test_MUL_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [91343852333181432387730302044767688728495783680]) - - def test_MUL_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MUL_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MUL_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MUL_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x02" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [108587248129216521041659901496828357798423901649189515989682796306847468945408], - ) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMMULMOD.py b/tests/ethereum/EVM/test_EVMMULMOD.py deleted file mode 100644 index 6e460d52f..000000000 --- a/tests/ethereum/EVM/test_EVMMULMOD.py +++ /dev/null @@ -1,17679 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_MULMOD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_MULMOD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_MULMOD_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MULMOD_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MULMOD_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_MULMOD_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [28948022309329048855892746252171976963317496166410141009864396001978282410224], - ) - - def test_MULMOD_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1809251394333065553493296640760748560207343510400633813116524750123642650391], - ) - - def test_MULMOD_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639687], - ) - - def test_MULMOD_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639439], - ) - - def test_MULMOD_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639191], - ) - - def test_MULMOD_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008593519205859030518839909394011324062893683996799], - ) - - def test_MULMOD_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MULMOD_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1809251394333065553493296640760748560207343510400633813116524750123642650391], - ) - - def test_MULMOD_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [108668161872129749806691129485692460397453569593438068400311267804301286703329], - ) - - def test_MULMOD_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820208], - ) - - def test_MULMOD_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [481]) - - def test_MULMOD_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820689], - ) - - def test_MULMOD_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [91534152025542227038538073507360954746680149896]) - - def test_MULMOD_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639687], - ) - - def test_MULMOD_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820208], - ) - - def test_MULMOD_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MULMOD_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639439], - ) - - def test_MULMOD_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [481]) - - def test_MULMOD_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1024]) - - def test_MULMOD_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MULMOD_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639191], - ) - - def test_MULMOD_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820689], - ) - - def test_MULMOD_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2304]) - - def test_MULMOD_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MULMOD_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MULMOD_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008593519205859030518839909394011324062893683996799], - ) - - def test_MULMOD_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [91534152025542227038538073507360954746680149896]) - - def test_MULMOD_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MULMOD_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MULMOD_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [108587248129216521041659901496828357798423901649189515989682796627103442447309], - ) - - def test_MULMOD_82(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_83(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_84(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_85(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_86(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_87(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_88(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_89(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_90(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_91(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_92(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_93(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_94(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_95(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_96(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_97(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_98(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_99(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_100(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_101(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_102(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_103(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_104(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_105(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_106(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_107(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_108(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_109(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_110(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_111(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_112(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_113(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_114(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_115(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_116(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_117(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_118(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_119(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_120(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_121(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_122(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_123(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_124(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_125(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_126(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_127(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_128(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_129(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_130(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_131(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_132(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_133(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_134(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_135(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_136(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_137(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_138(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_139(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_140(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_141(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_142(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_143(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_144(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_145(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_146(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_147(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_148(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_149(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_150(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_151(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_152(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_153(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_154(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_155(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_156(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_157(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_158(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_159(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_160(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_161(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_162(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_163(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_164(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_165(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_166(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_167(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_168(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_169(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_170(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_171(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_172(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_173(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_174(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_175(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_176(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_177(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_178(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_179(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_180(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_181(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_182(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_183(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_184(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_185(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_186(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_187(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_188(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_189(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_190(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_191(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_192(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_193(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_194(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_195(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_196(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_197(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_198(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_199(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_200(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_201(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_202(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_203(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_204(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_205(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_206(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_207(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_208(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_209(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_210(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_211(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_212(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_213(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_214(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_215(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_216(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_217(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_218(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_219(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_220(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_221(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_222(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_223(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_224(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_225(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_226(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_227(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_228(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_229(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_230(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_231(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_232(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_233(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_234(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_235(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_236(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_237(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_238(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_239(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_240(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_241(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_242(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_243(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_244(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [961]) - - def test_MULMOD_245(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_246(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_MULMOD_247(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_248(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [54277541829991966604798899222822456806220305312019014393495742503709279519201], - ) - - def test_MULMOD_249(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [496]) - - def test_MULMOD_250(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [992]) - - def test_MULMOD_251(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1488]) - - def test_MULMOD_252(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [188777294821908293601309290892519890038891286272]) - - def test_MULMOD_253(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_254(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_255(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_256(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_257(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_258(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_259(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_260(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_261(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_262(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_MULMOD_263(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_264(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_265(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_266(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MULMOD_267(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_268(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_269(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_270(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MULMOD_271(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_272(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_273(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_274(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_275(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_276(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_277(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_278(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_279(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_280(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [54277541829991966604798899222822456806220305312019014393495742503709279519201], - ) - - def test_MULMOD_281(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_282(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_MULMOD_283(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_284(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [54277541829991966604798899222822456806220305312019014393495742503709279518961], - ) - - def test_MULMOD_285(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MULMOD_286(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_287(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_288(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_289(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [496]) - - def test_MULMOD_290(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_291(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_292(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_293(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MULMOD_294(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MULMOD_295(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_296(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_297(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_298(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [992]) - - def test_MULMOD_299(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_300(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_301(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_302(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_303(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_304(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1024]) - - def test_MULMOD_305(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_306(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MULMOD_307(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1488]) - - def test_MULMOD_308(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_309(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_310(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_311(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_312(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_313(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_314(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2304]) - - def test_MULMOD_315(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MULMOD_316(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [188777294821908293601309290892519890038891286272]) - - def test_MULMOD_317(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_318(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MULMOD_319(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_320(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_321(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_322(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MULMOD_323(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MULMOD_324(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [50691203510558423329874408992484403871788909316369233969954014551082056186288], - ) - - def test_MULMOD_325(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [231361]) - - def test_MULMOD_326(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_327(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_MULMOD_328(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [123136]) - - def test_MULMOD_329(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_330(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285293567], - ) - - def test_MULMOD_331(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285285871], - ) - - def test_MULMOD_332(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285278175], - ) - - def test_MULMOD_333(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593278592404255597335755568049273997498948353520504591], - ) - - def test_MULMOD_334(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_335(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_336(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_337(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_338(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_339(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_340(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_341(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_342(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_343(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285300782], - ) - - def test_MULMOD_344(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_345(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_346(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_MULMOD_347(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_348(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_349(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_350(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_351(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MULMOD_352(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [123136]) - - def test_MULMOD_353(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_354(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_MULMOD_355(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [65536]) - - def test_MULMOD_356(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_357(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285297167], - ) - - def test_MULMOD_358(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285293071], - ) - - def test_MULMOD_359(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285288975], - ) - - def test_MULMOD_360(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593279962562040595057241384003804669014279280957259791], - ) - - def test_MULMOD_361(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_362(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_363(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_364(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_365(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_366(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_367(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_368(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_369(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_370(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285293567], - ) - - def test_MULMOD_371(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_372(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_373(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285297167], - ) - - def test_MULMOD_374(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_375(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MULMOD_376(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_377(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_378(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_379(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285285871], - ) - - def test_MULMOD_380(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_381(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_382(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285293071], - ) - - def test_MULMOD_383(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_384(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_385(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1024]) - - def test_MULMOD_386(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_387(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MULMOD_388(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285278175], - ) - - def test_MULMOD_389(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_390(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_391(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285288975], - ) - - def test_MULMOD_392(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_393(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_394(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_395(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2304]) - - def test_MULMOD_396(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MULMOD_397(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593278592404255597335755568049273997498948353520504591], - ) - - def test_MULMOD_398(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_399(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_MULMOD_400(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593279962562040595057241384003804669014279280957259791], - ) - - def test_MULMOD_401(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_402(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [97433442488726861213578988847752201310395502592]) - - def test_MULMOD_403(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [194866884977453722427157977695504402620791005184]) - - def test_MULMOD_404(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [292300327466180583640736966543256603931186507776]) - - def test_MULMOD_405(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [32164469232587832062103051183444185983291025151487202691157576561628995038], - ) - - def test_MULMOD_406(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_407(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_408(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_409(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_410(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_411(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_412(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_413(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_414(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_415(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_416(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_417(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_418(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_419(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_420(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_421(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_422(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_423(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_424(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_425(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_426(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_427(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_428(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_429(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_430(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_431(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_432(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_433(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_434(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_435(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_436(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_437(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_438(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_439(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_440(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_441(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_442(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_443(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_444(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_445(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_446(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_447(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_448(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_449(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_450(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_451(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_452(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_453(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_454(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_455(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_456(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_457(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_458(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_459(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_460(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_461(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_462(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_463(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_464(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_465(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_466(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_467(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_468(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_469(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_470(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_471(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_472(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_473(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_474(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_475(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_476(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_477(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_478(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_479(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_480(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_481(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_482(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_483(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_484(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_485(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_486(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_487(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_488(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_489(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_MULMOD_490(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_491(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_MULMOD_492(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_493(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_494(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_495(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_496(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_497(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_498(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_499(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_500(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_501(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_502(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_503(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_504(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_505(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_MULMOD_506(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_507(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_508(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_509(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_510(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_511(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_512(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_513(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_514(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_515(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_516(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_517(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_518(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_519(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_520(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_521(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_522(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_523(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_MULMOD_524(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_525(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_526(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_527(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_528(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_529(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_530(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_531(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_532(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_533(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_534(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_535(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_536(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_537(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_538(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_539(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_540(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_541(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_542(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_543(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_544(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_545(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_546(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_547(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_548(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_549(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_550(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_551(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_552(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_553(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_554(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_555(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_556(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_557(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_558(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_559(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_560(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_561(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_562(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_563(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_564(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_565(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_566(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_567(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_568(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_MULMOD_569(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_570(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_571(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_572(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_MULMOD_573(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_574(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_575(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_576(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_577(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_578(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_579(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_580(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_581(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_582(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_583(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_584(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_585(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_586(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_MULMOD_587(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_588(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_589(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_590(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_MULMOD_591(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_592(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_593(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_594(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_595(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_596(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_597(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_598(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_599(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_600(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_601(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_602(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_603(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_604(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_MULMOD_605(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_606(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_MULMOD_607(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_608(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_609(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_610(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_611(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_612(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_613(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_614(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_615(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_616(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_617(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_618(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_619(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_620(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_621(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_622(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_623(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_624(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_625(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_626(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_627(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_628(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_629(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_630(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_631(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_632(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_633(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_634(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_635(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_636(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_637(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_638(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_639(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_640(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_641(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_642(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_643(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_644(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_645(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_646(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_647(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_648(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_649(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155544779788741370244678851449211392257]) - - def test_MULMOD_650(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_651(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_MULMOD_652(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155540074269713322909566543097236623632]) - - def test_MULMOD_653(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [4857637100074584289907403537776625]) - - def test_MULMOD_654(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [5192296858534827628530496329220080]) - - def test_MULMOD_655(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10384593717069655257060992658440160]) - - def test_MULMOD_656(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15576890575604482885591488987660240]) - - def test_MULMOD_657(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_658(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_659(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_660(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_661(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_662(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_663(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_664(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_665(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_666(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_667(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576255]) - - def test_MULMOD_668(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_669(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_MULMOD_670(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_MULMOD_671(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_MULMOD_672(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_673(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_674(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_675(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_676(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155540074269713322909566543097236623632]) - - def test_MULMOD_677(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_678(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_MULMOD_679(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155540236528990152049142958380408705536]) - - def test_MULMOD_680(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2271629875608991699168110571421456]) - - def test_MULMOD_681(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2596148429267413814265248164609792]) - - def test_MULMOD_682(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [5192296858534827628530496329219584]) - - def test_MULMOD_683(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [7788445287802241442795744493829376]) - - def test_MULMOD_684(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_685(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [4857637100074584289907403537776625]) - - def test_MULMOD_686(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_687(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_MULMOD_688(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2271629875608991699168110571421456]) - - def test_MULMOD_689(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [304236144054775344589584921002209]) - - def test_MULMOD_690(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288368]) - - def test_MULMOD_691(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576736]) - - def test_MULMOD_692(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [486777830487640090174734030865104]) - - def test_MULMOD_693(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_694(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [5192296858534827628530496329220080]) - - def test_MULMOD_695(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_696(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_MULMOD_697(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2596148429267413814265248164609792]) - - def test_MULMOD_698(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288368]) - - def test_MULMOD_699(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [256]) - - def test_MULMOD_700(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_701(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_702(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_703(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10384593717069655257060992658440160]) - - def test_MULMOD_704(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_705(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_MULMOD_706(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [5192296858534827628530496329219584]) - - def test_MULMOD_707(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [324518553658426726783156020576736]) - - def test_MULMOD_708(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [512]) - - def test_MULMOD_709(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1024]) - - def test_MULMOD_710(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_711(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_712(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15576890575604482885591488987660240]) - - def test_MULMOD_713(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_714(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_MULMOD_715(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [7788445287802241442795744493829376]) - - def test_MULMOD_716(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [486777830487640090174734030865104]) - - def test_MULMOD_717(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [768]) - - def test_MULMOD_718(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1536]) - - def test_MULMOD_719(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2304]) - - def test_MULMOD_720(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_721(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_722(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_723(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_724(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_725(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_726(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_727(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_728(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_MULMOD_729(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMNOT.py b/tests/ethereum/EVM/test_EVMNOT.py deleted file mode 100644 index bf952d1f2..000000000 --- a/tests/ethereum/EVM/test_EVMNOT.py +++ /dev/null @@ -1,261 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_NOT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_NOT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_NOT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_NOT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_NOT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819983], - ) - - def test_NOT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338672], - ) - - def test_NOT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639919], - ) - - def test_NOT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639903], - ) - - def test_NOT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639887], - ) - - def test_NOT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x19" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921023], - ) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMOR.py b/tests/ethereum/EVM/test_EVMOR.py deleted file mode 100644 index ed60c434a..000000000 --- a/tests/ethereum/EVM/test_EVMOR.py +++ /dev/null @@ -1,2037 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_OR(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_OR_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_OR_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_OR_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_OR_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_OR_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_OR_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_OR_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_OR_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_OR_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_OR_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_OR_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_OR_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_OR_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_OR_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_OR_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_OR_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819967], - ) - - def test_OR_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_OR_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_OR_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819967], - ) - - def test_OR_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_OR_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_OR_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_OR_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_OR_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_OR_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_OR_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_OR_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_OR_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_OR_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_OR_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_OR_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_OR_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_OR_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_OR_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_OR_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_OR_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_OR_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_OR_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_OR_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_OR_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_OR_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_OR_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_OR_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_OR_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_OR_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_OR_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_OR_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x17" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMORIGIN.py b/tests/ethereum/EVM/test_EVMORIGIN.py deleted file mode 100644 index b8a83ba85..000000000 --- a/tests/ethereum/EVM/test_EVMORIGIN.py +++ /dev/null @@ -1,56 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_ORIGIN(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_ORIGIN_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - owner_account = world.create_account(balance=1000) - contract_account = world.create_account(balance=1000, code=b"2") - - world._open_transaction("CALL", contract_account, 10, "", owner_account, 0) - - new_vm = world.current_vm - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [owner_account]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMPOP.py b/tests/ethereum/EVM/test_EVMPOP.py deleted file mode 100644 index 6875a3932..000000000 --- a/tests/ethereum/EVM/test_EVMPOP.py +++ /dev/null @@ -1,237 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_POP(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_POP_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_POP_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"P" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMPUSH.py b/tests/ethereum/EVM/test_EVMPUSH.py deleted file mode 100644 index f2696576b..000000000 --- a/tests/ethereum/EVM/test_EVMPUSH.py +++ /dev/null @@ -1,711 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_PUSH(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_PUSH_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"`" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 2) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"a" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 3) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 4) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 5) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 6) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"e" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 7) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"f" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 8) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"g" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 9) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"h" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 10) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"i" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 11) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"j" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 12) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"k" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 13) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"l" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 14) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"m" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 15) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"n" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 16) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"o" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 17) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"p" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 18) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"q" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 19) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"r" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 20) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"s" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 21) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"t" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 22) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"u" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 23) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"v" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 24) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"w" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 25) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"x" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 26) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"y" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 27) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"z" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 28) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"{" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 29) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"|" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 30) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"}" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 31) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"~" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 32) - self.assertEqual(new_vm.stack, [0]) - - def test_PUSH_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x7f" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 33) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMREVERT.py b/tests/ethereum/EVM/test_EVMREVERT.py deleted file mode 100644 index ff4b59f1b..000000000 --- a/tests/ethereum/EVM/test_EVMREVERT.py +++ /dev/null @@ -1,288 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os -from manticore.utils import config - -consts = config.get_group("evm") - - -class EVMTest_REVERT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def setUp(self): - self.saved_gas_config = consts.oog - consts.oog = "complete" - - def tearDown(self): - consts.oog = self.saved_gas_config - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - except evm.EndTx as e: - last_exception = e.result - - return last_exception, last_returned - - def test_REVERT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_REVERT_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - caller = origin = 0x111111111111111111111111111111111111100 - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - world.create_account(address=address) - world.create_account(address=caller) - - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "REVERT") - self.assertEqual(new_vm.stack, []) - - def test_REVERT_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xfd" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSDIV.py b/tests/ethereum/EVM/test_EVMSDIV.py deleted file mode 100644 index bf144d91b..000000000 --- a/tests/ethereum/EVM/test_EVMSDIV.py +++ /dev/null @@ -1,1950 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SDIV(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SDIV_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SDIV_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_SDIV_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338673], - ) - - def test_SDIV_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SDIV_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_SDIV_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639888], - ) - - def test_SDIV_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921024], - ) - - def test_SDIV_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SDIV_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SDIV_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SDIV_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SDIV_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SDIV_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SDIV_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SDIV_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SDIV_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301247], - ) - - def test_SDIV_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [226156424291633194186662080095093570025917938800079226639565593765455331328], - ) - - def test_SDIV_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_SDIV_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [3]) - - def test_SDIV_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [380599384721589301615542925186532036368732432]) - - def test_SDIV_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1809251394333065553493296640760748560207343510400633813116524750123642650623], - ) - - def test_SDIV_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [113078212145816597093331040047546785012958969400039613319782796882727665664], - ) - - def test_SDIV_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [190299692360794650807771462593266018184366216]) - - def test_SDIV_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [1206167596222043702328864427173832373471562340267089208744349833415761767082], - ) - - def test_SDIV_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [75385474763877731395554026698364523341972646266693075546521864588485110442], - ) - - def test_SDIV_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SDIV_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [126866461573863100538514308395510678789577477]) - - def test_SDIV_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [9507379501711720511225274040320]) - - def test_SDIV_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [594211218856982531951579627520]) - - def test_SDIV_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SDIV_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x05" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSELFDESTRUCT.py b/tests/ethereum/EVM/test_EVMSELFDESTRUCT.py deleted file mode 100644 index 4fb2a0a82..000000000 --- a/tests/ethereum/EVM/test_EVMSELFDESTRUCT.py +++ /dev/null @@ -1,440 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SELFDESTRUCT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SELFDESTRUCT" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - except evm.EndTx as e: - last_exception = e.result - - return last_exception, last_returned - - def test_SELFDESTRUCT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x303232323232323232323232323232323232323 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x0 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x1 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0xF - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x10 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x20 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x30 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - def test_SELFDESTRUCT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x3032323232323232323232323232323232323230 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x111111111111111111111111111111111111100 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - balance = 0 - code = b"" - storage = {} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\xff" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "SELFDESTRUCT") - self.assertEqual(new_vm.gas, 995000) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSGT.py b/tests/ethereum/EVM/test_EVMSGT.py deleted file mode 100644 index 2a373dd57..000000000 --- a/tests/ethereum/EVM/test_EVMSGT.py +++ /dev/null @@ -1,1902 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SGT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SGT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SGT_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SGT_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x13" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSHA3.py b/tests/ethereum/EVM/test_EVMSHA3.py deleted file mode 100644 index ad40a28d8..000000000 --- a/tests/ethereum/EVM/test_EVMSHA3.py +++ /dev/null @@ -1,2380 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os -from manticore.utils import config - -consts = config.get_group("evm") - - -class EVMTest_SHA3(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def setUp(self): - self.saved_gas_config = consts.oog - consts.oog = "complete" - - def tearDown(self): - consts.oog = self.saved_gas_config - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SHA3_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [89477152217924674838424037953991966239322087453347756267410168184682657981552], - ) - - def test_SHA3_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - new_vm.memory[0] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [38468488817986530247887777414678086216360049057372179296543030553902011157846], - ) - - def test_SHA3_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - new_vm.memory[1] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [38468488817986530247887777414678086216360049057372179296543030553902011157846], - ) - - def test_SHA3_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - new_vm.memory[16] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [38468488817986530247887777414678086216360049057372179296543030553902011157846], - ) - - def test_SHA3_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - new_vm.memory[32] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [38468488817986530247887777414678086216360049057372179296543030553902011157846], - ) - - def test_SHA3_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - new_vm.memory[48] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [38468488817986530247887777414678086216360049057372179296543030553902011157846], - ) - - def test_SHA3_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - new_vm.memory[0] = 88 - new_vm.memory[1] = 88 - new_vm.memory[2] = 88 - new_vm.memory[3] = 88 - new_vm.memory[4] = 88 - new_vm.memory[5] = 88 - new_vm.memory[6] = 88 - new_vm.memory[7] = 88 - new_vm.memory[8] = 88 - new_vm.memory[9] = 88 - new_vm.memory[10] = 88 - new_vm.memory[11] = 88 - new_vm.memory[12] = 88 - new_vm.memory[13] = 88 - new_vm.memory[14] = 88 - new_vm.memory[15] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [4734955612022241403446959571200475901047349850262219251209420455990604867461], - ) - - def test_SHA3_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - new_vm.memory[1] = 88 - new_vm.memory[2] = 88 - new_vm.memory[3] = 88 - new_vm.memory[4] = 88 - new_vm.memory[5] = 88 - new_vm.memory[6] = 88 - new_vm.memory[7] = 88 - new_vm.memory[8] = 88 - new_vm.memory[9] = 88 - new_vm.memory[10] = 88 - new_vm.memory[11] = 88 - new_vm.memory[12] = 88 - new_vm.memory[13] = 88 - new_vm.memory[14] = 88 - new_vm.memory[15] = 88 - new_vm.memory[16] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [4734955612022241403446959571200475901047349850262219251209420455990604867461], - ) - - def test_SHA3_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [4734955612022241403446959571200475901047349850262219251209420455990604867461], - ) - - def test_SHA3_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [4734955612022241403446959571200475901047349850262219251209420455990604867461], - ) - - def test_SHA3_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - new_vm.memory[48] = 88 - new_vm.memory[49] = 88 - new_vm.memory[50] = 88 - new_vm.memory[51] = 88 - new_vm.memory[52] = 88 - new_vm.memory[53] = 88 - new_vm.memory[54] = 88 - new_vm.memory[55] = 88 - new_vm.memory[56] = 88 - new_vm.memory[57] = 88 - new_vm.memory[58] = 88 - new_vm.memory[59] = 88 - new_vm.memory[60] = 88 - new_vm.memory[61] = 88 - new_vm.memory[62] = 88 - new_vm.memory[63] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [4734955612022241403446959571200475901047349850262219251209420455990604867461], - ) - - def test_SHA3_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - new_vm.memory[0] = 88 - new_vm.memory[1] = 88 - new_vm.memory[2] = 88 - new_vm.memory[3] = 88 - new_vm.memory[4] = 88 - new_vm.memory[5] = 88 - new_vm.memory[6] = 88 - new_vm.memory[7] = 88 - new_vm.memory[8] = 88 - new_vm.memory[9] = 88 - new_vm.memory[10] = 88 - new_vm.memory[11] = 88 - new_vm.memory[12] = 88 - new_vm.memory[13] = 88 - new_vm.memory[14] = 88 - new_vm.memory[15] = 88 - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [55858784234176438416533633276923373318937222299816437706613930531814037745581], - ) - - def test_SHA3_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - new_vm.memory[1] = 88 - new_vm.memory[2] = 88 - new_vm.memory[3] = 88 - new_vm.memory[4] = 88 - new_vm.memory[5] = 88 - new_vm.memory[6] = 88 - new_vm.memory[7] = 88 - new_vm.memory[8] = 88 - new_vm.memory[9] = 88 - new_vm.memory[10] = 88 - new_vm.memory[11] = 88 - new_vm.memory[12] = 88 - new_vm.memory[13] = 88 - new_vm.memory[14] = 88 - new_vm.memory[15] = 88 - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - new_vm.memory[32] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [55858784234176438416533633276923373318937222299816437706613930531814037745581], - ) - - def test_SHA3_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [55858784234176438416533633276923373318937222299816437706613930531814037745581], - ) - - def test_SHA3_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - new_vm.memory[48] = 88 - new_vm.memory[49] = 88 - new_vm.memory[50] = 88 - new_vm.memory[51] = 88 - new_vm.memory[52] = 88 - new_vm.memory[53] = 88 - new_vm.memory[54] = 88 - new_vm.memory[55] = 88 - new_vm.memory[56] = 88 - new_vm.memory[57] = 88 - new_vm.memory[58] = 88 - new_vm.memory[59] = 88 - new_vm.memory[60] = 88 - new_vm.memory[61] = 88 - new_vm.memory[62] = 88 - new_vm.memory[63] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [55858784234176438416533633276923373318937222299816437706613930531814037745581], - ) - - def test_SHA3_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - new_vm.memory[48] = 88 - new_vm.memory[49] = 88 - new_vm.memory[50] = 88 - new_vm.memory[51] = 88 - new_vm.memory[52] = 88 - new_vm.memory[53] = 88 - new_vm.memory[54] = 88 - new_vm.memory[55] = 88 - new_vm.memory[56] = 88 - new_vm.memory[57] = 88 - new_vm.memory[58] = 88 - new_vm.memory[59] = 88 - new_vm.memory[60] = 88 - new_vm.memory[61] = 88 - new_vm.memory[62] = 88 - new_vm.memory[63] = 88 - new_vm.memory[64] = 88 - new_vm.memory[65] = 88 - new_vm.memory[66] = 88 - new_vm.memory[67] = 88 - new_vm.memory[68] = 88 - new_vm.memory[69] = 88 - new_vm.memory[70] = 88 - new_vm.memory[71] = 88 - new_vm.memory[72] = 88 - new_vm.memory[73] = 88 - new_vm.memory[74] = 88 - new_vm.memory[75] = 88 - new_vm.memory[76] = 88 - new_vm.memory[77] = 88 - new_vm.memory[78] = 88 - new_vm.memory[79] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [55858784234176438416533633276923373318937222299816437706613930531814037745581], - ) - - def test_SHA3_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - new_vm.memory[0] = 88 - new_vm.memory[1] = 88 - new_vm.memory[2] = 88 - new_vm.memory[3] = 88 - new_vm.memory[4] = 88 - new_vm.memory[5] = 88 - new_vm.memory[6] = 88 - new_vm.memory[7] = 88 - new_vm.memory[8] = 88 - new_vm.memory[9] = 88 - new_vm.memory[10] = 88 - new_vm.memory[11] = 88 - new_vm.memory[12] = 88 - new_vm.memory[13] = 88 - new_vm.memory[14] = 88 - new_vm.memory[15] = 88 - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [87315138422451183025224871972802370450373932520512056513148796263698858401046], - ) - - def test_SHA3_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - new_vm.memory[1] = 88 - new_vm.memory[2] = 88 - new_vm.memory[3] = 88 - new_vm.memory[4] = 88 - new_vm.memory[5] = 88 - new_vm.memory[6] = 88 - new_vm.memory[7] = 88 - new_vm.memory[8] = 88 - new_vm.memory[9] = 88 - new_vm.memory[10] = 88 - new_vm.memory[11] = 88 - new_vm.memory[12] = 88 - new_vm.memory[13] = 88 - new_vm.memory[14] = 88 - new_vm.memory[15] = 88 - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - new_vm.memory[48] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [87315138422451183025224871972802370450373932520512056513148796263698858401046], - ) - - def test_SHA3_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - new_vm.memory[16] = 88 - new_vm.memory[17] = 88 - new_vm.memory[18] = 88 - new_vm.memory[19] = 88 - new_vm.memory[20] = 88 - new_vm.memory[21] = 88 - new_vm.memory[22] = 88 - new_vm.memory[23] = 88 - new_vm.memory[24] = 88 - new_vm.memory[25] = 88 - new_vm.memory[26] = 88 - new_vm.memory[27] = 88 - new_vm.memory[28] = 88 - new_vm.memory[29] = 88 - new_vm.memory[30] = 88 - new_vm.memory[31] = 88 - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - new_vm.memory[48] = 88 - new_vm.memory[49] = 88 - new_vm.memory[50] = 88 - new_vm.memory[51] = 88 - new_vm.memory[52] = 88 - new_vm.memory[53] = 88 - new_vm.memory[54] = 88 - new_vm.memory[55] = 88 - new_vm.memory[56] = 88 - new_vm.memory[57] = 88 - new_vm.memory[58] = 88 - new_vm.memory[59] = 88 - new_vm.memory[60] = 88 - new_vm.memory[61] = 88 - new_vm.memory[62] = 88 - new_vm.memory[63] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [87315138422451183025224871972802370450373932520512056513148796263698858401046], - ) - - def test_SHA3_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - new_vm.memory[32] = 88 - new_vm.memory[33] = 88 - new_vm.memory[34] = 88 - new_vm.memory[35] = 88 - new_vm.memory[36] = 88 - new_vm.memory[37] = 88 - new_vm.memory[38] = 88 - new_vm.memory[39] = 88 - new_vm.memory[40] = 88 - new_vm.memory[41] = 88 - new_vm.memory[42] = 88 - new_vm.memory[43] = 88 - new_vm.memory[44] = 88 - new_vm.memory[45] = 88 - new_vm.memory[46] = 88 - new_vm.memory[47] = 88 - new_vm.memory[48] = 88 - new_vm.memory[49] = 88 - new_vm.memory[50] = 88 - new_vm.memory[51] = 88 - new_vm.memory[52] = 88 - new_vm.memory[53] = 88 - new_vm.memory[54] = 88 - new_vm.memory[55] = 88 - new_vm.memory[56] = 88 - new_vm.memory[57] = 88 - new_vm.memory[58] = 88 - new_vm.memory[59] = 88 - new_vm.memory[60] = 88 - new_vm.memory[61] = 88 - new_vm.memory[62] = 88 - new_vm.memory[63] = 88 - new_vm.memory[64] = 88 - new_vm.memory[65] = 88 - new_vm.memory[66] = 88 - new_vm.memory[67] = 88 - new_vm.memory[68] = 88 - new_vm.memory[69] = 88 - new_vm.memory[70] = 88 - new_vm.memory[71] = 88 - new_vm.memory[72] = 88 - new_vm.memory[73] = 88 - new_vm.memory[74] = 88 - new_vm.memory[75] = 88 - new_vm.memory[76] = 88 - new_vm.memory[77] = 88 - new_vm.memory[78] = 88 - new_vm.memory[79] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [87315138422451183025224871972802370450373932520512056513148796263698858401046], - ) - - def test_SHA3_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - new_vm.memory[48] = 88 - new_vm.memory[49] = 88 - new_vm.memory[50] = 88 - new_vm.memory[51] = 88 - new_vm.memory[52] = 88 - new_vm.memory[53] = 88 - new_vm.memory[54] = 88 - new_vm.memory[55] = 88 - new_vm.memory[56] = 88 - new_vm.memory[57] = 88 - new_vm.memory[58] = 88 - new_vm.memory[59] = 88 - new_vm.memory[60] = 88 - new_vm.memory[61] = 88 - new_vm.memory[62] = 88 - new_vm.memory[63] = 88 - new_vm.memory[64] = 88 - new_vm.memory[65] = 88 - new_vm.memory[66] = 88 - new_vm.memory[67] = 88 - new_vm.memory[68] = 88 - new_vm.memory[69] = 88 - new_vm.memory[70] = 88 - new_vm.memory[71] = 88 - new_vm.memory[72] = 88 - new_vm.memory[73] = 88 - new_vm.memory[74] = 88 - new_vm.memory[75] = 88 - new_vm.memory[76] = 88 - new_vm.memory[77] = 88 - new_vm.memory[78] = 88 - new_vm.memory[79] = 88 - new_vm.memory[80] = 88 - new_vm.memory[81] = 88 - new_vm.memory[82] = 88 - new_vm.memory[83] = 88 - new_vm.memory[84] = 88 - new_vm.memory[85] = 88 - new_vm.memory[86] = 88 - new_vm.memory[87] = 88 - new_vm.memory[88] = 88 - new_vm.memory[89] = 88 - new_vm.memory[90] = 88 - new_vm.memory[91] = 88 - new_vm.memory[92] = 88 - new_vm.memory[93] = 88 - new_vm.memory[94] = 88 - new_vm.memory[95] = 88 - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [87315138422451183025224871972802370450373932520512056513148796263698858401046], - ) - - def test_SHA3_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - def test_SHA3_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b" " - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, "OOG") - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSHIFT.py b/tests/ethereum/EVM/test_EVMSHIFT.py deleted file mode 100644 index 897c5e114..000000000 --- a/tests/ethereum/EVM/test_EVMSHIFT.py +++ /dev/null @@ -1,885 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SHIFT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SHL_0(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SHL_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_SHL_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819968], - ) - - def test_SHL_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHL_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(257) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHL_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SHL_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_SHL_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819968], - ) - - def test_SHL_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHL_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHL_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819967) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_SHR_0(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SHR_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHR_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [28948022309329048855892746252171976963317496166410141009864396001978282409984], - ) - - def test_SHR_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SHR_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHR_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(257) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHR_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SHR_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819967], - ) - - def test_SHR_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SHR_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SHR_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1c" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SAR_0(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SAR_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SAR_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [86844066927987146567678238756515930889952488499230423029593188005934847229952], - ) - - def test_SAR_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819968) - new_vm._push(257) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SAR_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SAR_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(28948022309329048855892746252171976963317496166410141009864396001978282409984) - new_vm._push(254) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SAR_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819967) - new_vm._push(248) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [127]) - - def test_SAR_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819967) - new_vm._push(254) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SAR_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819967) - new_vm._push(255) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SAR_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = 0x111111111111111111111111111111111111100 - value = 10000 - bytecode = b"\x1d" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819967) - new_vm._push(256) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSIGNEXTEND.py b/tests/ethereum/EVM/test_EVMSIGNEXTEND.py deleted file mode 100644 index 9b5ede399..000000000 --- a/tests/ethereum/EVM/test_EVMSIGNEXTEND.py +++ /dev/null @@ -1,1974 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SIGNEXTEND(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SIGNEXTEND_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SIGNEXTEND_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SIGNEXTEND_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SIGNEXTEND_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SIGNEXTEND_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SIGNEXTEND_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SIGNEXTEND_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SIGNEXTEND_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SIGNEXTEND_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SIGNEXTEND_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SIGNEXTEND_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SIGNEXTEND_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SIGNEXTEND_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SIGNEXTEND_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SIGNEXTEND_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SIGNEXTEND_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SIGNEXTEND_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SIGNEXTEND_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SIGNEXTEND_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SIGNEXTEND_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SIGNEXTEND_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SIGNEXTEND_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SIGNEXTEND_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SIGNEXTEND_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SIGNEXTEND_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SIGNEXTEND_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [4352]) - - def test_SIGNEXTEND_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SIGNEXTEND_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SIGNEXTEND_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [5807485728784016443108259966835510808832]) - - def test_SIGNEXTEND_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SIGNEXTEND_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SIGNEXTEND_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x0b" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSLOAD.py b/tests/ethereum/EVM/test_EVMSLOAD.py deleted file mode 100644 index 60df91843..000000000 --- a/tests/ethereum/EVM/test_EVMSLOAD.py +++ /dev/null @@ -1,293 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SLOAD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SLOAD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 0 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLOAD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {0: 15589350798196297794172638215640352209663280458410} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15589350798196297794172638215640352209663280458410]) - - def test_SLOAD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {1: 17148285878015927573589902037204387430629608504251} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17148285878015927573589902037204387430629608504251]) - - def test_SLOAD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLOAD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLOAD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {16: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLOAD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {32: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLOAD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {48: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLOAD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"T" - storage = {6089590155545428825848686802984512581899718912: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"T" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSLT.py b/tests/ethereum/EVM/test_EVMSLT.py deleted file mode 100644 index d99fe1f8a..000000000 --- a/tests/ethereum/EVM/test_EVMSLT.py +++ /dev/null @@ -1,1902 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SLT(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SLT_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SLT_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SLT_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x12" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSMOD.py b/tests/ethereum/EVM/test_EVMSMOD.py deleted file mode 100644 index 389e4a52d..000000000 --- a/tests/ethereum/EVM/test_EVMSMOD.py +++ /dev/null @@ -1,1926 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SMOD(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SMOD_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SMOD_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SMOD_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SMOD_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SMOD_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SMOD_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SMOD_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SMOD_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SMOD_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301007], - ) - - def test_SMOD_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SMOD_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SMOD_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SMOD_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SMOD_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SMOD_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SMOD_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SMOD_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SMOD_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SMOD_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SMOD_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SMOD_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_SMOD_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SMOD_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SMOD_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SMOD_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SMOD_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [162259276829213363391578010288112]) - - def test_SMOD_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [10141204801825835211973625643023]) - - def test_SMOD_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SMOD_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SMOD_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SMOD_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x07" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSSTORE.py b/tests/ethereum/EVM/test_EVMSSTORE.py deleted file mode 100644 index 0019f4b78..000000000 --- a/tests/ethereum/EVM/test_EVMSSTORE.py +++ /dev/null @@ -1,2452 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SSTORE(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SSTORE_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 0: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 1: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 3618502788666131106986593281521497120414687020801267626233049500247285301263: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 16: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 32: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 48: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 6089590155545428825848686802984512581899718912: 115792089237316195423570985008687907853269984665640564039457584007913129639935 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 0 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {6089590155545428825848686802984512581899718912: 0} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 1 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {57896044618658097711785492504343953926634992332820282019728792003956564819952: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {6089590155545428825848686802984512581899718912: 1} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 57896044618658097711785492504343953926634992332820282019728792003956564819952} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 57896044618658097711785492504343953926634992332820282019728792003956564819952} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 3618502788666131106986593281521497120414687020801267626233049500247285301263: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 16: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 32: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 48: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 6089590155545428825848686802984512581899718912: 57896044618658097711785492504343953926634992332820282019728792003956564819952 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 3618502788666131106986593281521497120414687020801267626233049500247285301263 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 3618502788666131106986593281521497120414687020801267626233049500247285301263} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 3618502788666131106986593281521497120414687020801267626233049500247285301263} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 3618502788666131106986593281521497120414687020801267626233049500247285301263 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 3618502788666131106986593281521497120414687020801267626233049500247285301263: 3618502788666131106986593281521497120414687020801267626233049500247285301263 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 3618502788666131106986593281521497120414687020801267626233049500247285301263} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 3618502788666131106986593281521497120414687020801267626233049500247285301263} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 3618502788666131106986593281521497120414687020801267626233049500247285301263} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 6089590155545428825848686802984512581899718912: 3618502788666131106986593281521497120414687020801267626233049500247285301263 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 16 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 16 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {6089590155545428825848686802984512581899718912: 16} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 32 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 32 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {6089590155545428825848686802984512581899718912: 32} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 48 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 48 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {3618502788666131106986593281521497120414687020801267626233049500247285301263: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {6089590155545428825848686802984512581899718912: 48} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 115792089237316195423570985008687907853269984665640564039457584007913129639935: 6089590155545428825848686802984512581899718912 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {0: 6089590155545428825848686802984512581899718912} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {1: 6089590155545428825848686802984512581899718912} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 57896044618658097711785492504343953926634992332820282019728792003956564819952: 6089590155545428825848686802984512581899718912 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 3618502788666131106986593281521497120414687020801267626233049500247285301263: 6089590155545428825848686802984512581899718912 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {16: 6089590155545428825848686802984512581899718912} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {32: 6089590155545428825848686802984512581899718912} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = {48: 6089590155545428825848686802984512581899718912} - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - def test_SSTORE_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - balance = None - code = b"U" - storage = { - 6089590155545428825848686802984512581899718912: 6089590155545428825848686802984512581899718912 - } - world.create_account(address=address, balance=balance, code=code, storage=storage) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"U" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, []) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMSUB.py b/tests/ethereum/EVM/test_EVMSUB.py deleted file mode 100644 index ddfbf3adb..000000000 --- a/tests/ethereum/EVM/test_EVMSUB.py +++ /dev/null @@ -1,2055 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_SUB(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_SUB_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SUB_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [2]) - - def test_SUB_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_SUB_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301264], - ) - - def test_SUB_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_SUB_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_SUB_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_SUB_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_SUB_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SUB_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_SUB_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_SUB_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_SUB_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SUB_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SUB_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_SUB_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_SUB_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_SUB_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_SUB_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819951], - ) - - def test_SUB_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301262], - ) - - def test_SUB_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [15]) - - def test_SUB_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [31]) - - def test_SUB_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [47]) - - def test_SUB_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718911]) - - def test_SUB_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819983], - ) - - def test_SUB_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819984], - ) - - def test_SUB_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819985], - ) - - def test_SUB_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [61514547407324228818772085785865451047049679353621549645961841504203850121247], - ) - - def test_SUB_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820000], - ) - - def test_SUB_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820016], - ) - - def test_SUB_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564820032], - ) - - def test_SUB_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504350043516790537761646130706531776516538464538896], - ) - - def test_SUB_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338672], - ) - - def test_SUB_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338673], - ) - - def test_SUB_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338674], - ) - - def test_SUB_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [54277541829991966604798899222822456806220305312019014393495742503709279518689], - ) - - def test_SUB_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338689], - ) - - def test_SUB_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338705], - ) - - def test_SUB_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338721], - ) - - def test_SUB_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727172500323010843073665145100027519020247744057585], - ) - - def test_SUB_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639919], - ) - - def test_SUB_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SUB_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639921], - ) - - def test_SUB_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819936], - ) - - def test_SUB_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301247], - ) - - def test_SUB_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SUB_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_SUB_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718896]) - - def test_SUB_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639903], - ) - - def test_SUB_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_SUB_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639905], - ) - - def test_SUB_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819920], - ) - - def test_SUB_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301231], - ) - - def test_SUB_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SUB_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_SUB_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718880]) - - def test_SUB_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639887], - ) - - def test_SUB_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639888], - ) - - def test_SUB_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639889], - ) - - def test_SUB_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819904], - ) - - def test_SUB_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301215], - ) - - def test_SUB_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639904], - ) - - def test_SUB_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639920], - ) - - def test_SUB_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_SUB_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718864]) - - def test_SUB_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921023], - ) - - def test_SUB_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921024], - ) - - def test_SUB_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921025], - ) - - def test_SUB_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504337864336479446903994433332925807491374665101040], - ) - - def test_SUB_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281515407530259141591975418939430064987665385582351], - ) - - def test_SUB_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921040], - ) - - def test_SUB_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921056], - ) - - def test_SUB_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921072], - ) - - def test_SUB_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x03" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/EVM/test_EVMXOR.py b/tests/ethereum/EVM/test_EVMXOR.py deleted file mode 100644 index ee028f828..000000000 --- a/tests/ethereum/EVM/test_EVMXOR.py +++ /dev/null @@ -1,2028 +0,0 @@ -import struct -import unittest -import json -from manticore.platforms import evm -from manticore.core import state -from manticore.core.smtlib import Operators, ConstraintSet -import os - - -class EVMTest_XOR(unittest.TestCase): - _multiprocess_can_split_ = True - maxDiff = None - - def _execute(self, new_vm): - last_returned = None - last_exception = None - try: - new_vm.execute() - except evm.Stop as e: - last_exception = "STOP" - except evm.NotEnoughGas: - last_exception = "OOG" - except evm.StackUnderflow: - last_exception = "INSUFFICIENT STACK" - except evm.InvalidOpcode: - last_exception = "INVALID" - except evm.SelfDestruct: - last_exception = "SUICIDED" - except evm.Return as e: - last_exception = "RETURN" - last_returned = e.data - except evm.Revert: - last_exception = "REVERT" - - return last_exception, last_returned - - def test_XOR_1(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_2(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_XOR_3(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_XOR_4(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819983], - ) - - def test_XOR_5(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338672], - ) - - def test_XOR_6(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639919], - ) - - def test_XOR_7(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639903], - ) - - def test_XOR_8(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639887], - ) - - def test_XOR_9(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921023], - ) - - def test_XOR_10(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639935], - ) - - def test_XOR_11(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_12(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_XOR_13(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_XOR_14(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_XOR_15(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_XOR_16(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_XOR_17(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_XOR_18(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(0) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_XOR_19(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639934], - ) - - def test_XOR_20(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [1]) - - def test_XOR_21(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_22(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_XOR_23(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301262], - ) - - def test_XOR_24(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_XOR_25(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_XOR_26(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_XOR_27(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(1) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_XOR_28(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819983], - ) - - def test_XOR_29(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819952], - ) - - def test_XOR_30(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819953], - ) - - def test_XOR_31(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_32(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [54277541829991966604798899222822456806220305312019014393495742503709279518719], - ) - - def test_XOR_33(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819936], - ) - - def test_XOR_34(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819920], - ) - - def test_XOR_35(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819904], - ) - - def test_XOR_36(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504337864336479446903994433332925807491374665101040], - ) - - def test_XOR_37(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [112173586448650064316584391727166410732855297644839296413224534507665844338672], - ) - - def test_XOR_38(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301263], - ) - - def test_XOR_39(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301262], - ) - - def test_XOR_40(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [54277541829991966604798899222822456806220305312019014393495742503709279518719], - ) - - def test_XOR_41(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_42(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_XOR_43(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_XOR_44(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_XOR_45(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_XOR_46(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639919], - ) - - def test_XOR_47(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_XOR_48(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [17]) - - def test_XOR_49(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819936], - ) - - def test_XOR_50(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301279], - ) - - def test_XOR_51(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_52(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_XOR_53(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_XOR_54(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(16) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_XOR_55(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639903], - ) - - def test_XOR_56(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_XOR_57(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [33]) - - def test_XOR_58(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819920], - ) - - def test_XOR_59(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301295], - ) - - def test_XOR_60(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_XOR_61(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_62(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_XOR_63(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(32) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_XOR_64(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008687907853269984665640564039457584007913129639887], - ) - - def test_XOR_65(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [48]) - - def test_XOR_66(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [49]) - - def test_XOR_67(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504343953926634992332820282019728792003956564819904], - ) - - def test_XOR_68(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281521497120414687020801267626233049500247285301311], - ) - - def test_XOR_69(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [32]) - - def test_XOR_70(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [16]) - - def test_XOR_71(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - def test_XOR_72(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(48) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_XOR_73(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [115792089237316195423570985008681818263114439236814715352654599495331229921023], - ) - - def test_XOR_74(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(0) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718912]) - - def test_XOR_75(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(1) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718913]) - - def test_XOR_76(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [57896044618658097711785492504337864336479446903994433332925807491374665101040], - ) - - def test_XOR_77(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual( - new_vm.stack, - [3618502788666131106986593281527586710570232449627116313036034012829185020175], - ) - - def test_XOR_78(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(16) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718928]) - - def test_XOR_79(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(32) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718944]) - - def test_XOR_80(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(48) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [6089590155545428825848686802984512581899718960]) - - def test_XOR_81(self): - # Make the constraint store - constraints = ConstraintSet() - # make the ethereum world state - world = evm.EVMWorld(constraints) - - address = 0x222222222222222222222222222222222222200 - caller = origin = 0x111111111111111111111111111111111111100 - price = 0 - value = 10000 - bytecode = b"\x18" - data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} - gas = 1000000 - - new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) - new_vm._push(6089590155545428825848686802984512581899718912) - new_vm._push(6089590155545428825848686802984512581899718912) - last_exception, last_returned = self._execute(new_vm) - self.assertEqual(last_exception, None) - self.assertEqual(new_vm.pc, 1) - self.assertEqual(new_vm.stack, [0]) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/ethereum/test_detectors.py b/tests/ethereum/test_detectors.py index acd795ea1..b0431bf22 100644 --- a/tests/ethereum/test_detectors.py +++ b/tests/ethereum/test_detectors.py @@ -268,10 +268,12 @@ def test_delegatecall_ok(self): name = inspect.currentframe().f_code.co_name[5:] self._test(name, set()) + @unittest.skip("Too slow for these modern times") def test_delegatecall_ok1(self): name = inspect.currentframe().f_code.co_name[5:] self._test(name, set()) + @unittest.skip("Too slow for these modern times") def test_delegatecall_ok2(self): name = inspect.currentframe().f_code.co_name[5:] self._test(name, set()) diff --git a/tests/ethereum/test_general.py b/tests/ethereum/test_general.py index 302703466..998aadd8f 100644 --- a/tests/ethereum/test_general.py +++ b/tests/ethereum/test_general.py @@ -93,11 +93,10 @@ def test_parse_tx(self): } } """ - user_account = m.create_account(balance=1000, name="user_account") + user_account = m.create_account(balance=1000000, name="user_account") contract_account = m.solidity_create_contract( - source_code, owner=user_account, name="contract_account" + source_code, owner=user_account, name="contract_account", gas=36225 ) - calldata = binascii.unhexlify( b"9de4886f9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d" ) @@ -451,7 +450,7 @@ def tearDown(self): def test_solidity_create_contract_no_args(self): source_code = "contract A { constructor() {} }" - owner = self.mevm.create_account() + owner = self.mevm.create_account(balance=10 ** 10) # The default `args=()` makes it pass no arguments contract1 = self.mevm.solidity_create_contract(source_code, owner=owner) @@ -489,7 +488,7 @@ def test_solidity_create_contract_with_payable_constructor_and_balance_owner_ins def test_solidity_create_contract_with_payable_constructor(self): source_code = "contract A { constructor() public payable {} }" - owner = self.mevm.create_account(balance=1000) + owner = self.mevm.create_account(balance=10 ** 10) contract = self.mevm.solidity_create_contract(source_code, owner=owner, balance=100) @@ -523,7 +522,7 @@ def test_create_contract_with_string_args(self): source_code = ( "contract DontWork1{ string s; constructor(string memory s_) public{ s = s_;} }" ) - owner = self.mevm.create_account() + owner = self.mevm.create_account(balance=200000000) sym_args = self.mevm.make_symbolic_arguments("(string)") contract = self.mevm.solidity_create_contract(source_code, owner=owner, args=sym_args) @@ -532,7 +531,7 @@ def test_create_contract_with_string_args(self): def test_create_contract_two_instances(self): source_code = "contract A { constructor(uint32 arg) {} }" - owner = self.mevm.create_account() + owner = self.mevm.create_account(6000000) contracts = [ # When we pass no `args`, the default is `()` so it ends up with `b''` as constructor data @@ -551,7 +550,7 @@ def test_create_contract_two_instances(self): def test_contract_create_and_call_underscore_function(self): source_code = "contract A { function _f(uint x) returns (uint) { return x + 0x1234; } }" - owner = self.mevm.create_account() + owner = self.mevm.create_account(balance=300000000) contract = self.mevm.solidity_create_contract(source_code, owner=owner, args=[]) contract._f(123) @@ -559,7 +558,7 @@ def test_contract_create_and_call_underscore_function(self): def test_contract_create_and_access_non_existing_function(self): source_code = "contract A {}" - owner = self.mevm.create_account() + owner = self.mevm.create_account(balance=10000000) contract = self.mevm.solidity_create_contract(source_code, owner=owner, args=[]) with self.assertRaises(AttributeError) as e: @@ -577,7 +576,7 @@ def test_invalid_function_signature(self): } """ - user_account = self.mevm.create_account(balance=1000) + user_account = self.mevm.create_account(balance=10 ** 10) contract_account = self.mevm.solidity_create_contract(source_code, owner=user_account) with self.assertRaises(EthereumError) as ctx: contract_account.ret(self.mevm.make_symbolic_value(), signature="(uint8)") @@ -605,9 +604,10 @@ def test_selfdestruct_decoupled_account_delete(self): } } """ - user_account = self.mevm.create_account(balance=1000) + + user_account = self.mevm.create_account(balance=1000000000000000000000) contract_account = self.mevm.solidity_create_contract( - source_code, owner=user_account, contract_name="D", gas=9000000 + source_code, owner=user_account, contract_name="D", gas=900000 ) contract_account.t( gas=9000000 @@ -637,7 +637,7 @@ def test_states_querying_1325(self): """ Tests issue 1325. """ - owner = self.mevm.create_account(balance=1000) + owner = self.mevm.create_account(balance=10 ** 10) A = self.mevm.solidity_create_contract( "contract A { function foo() { revert(); } }", owner=owner ) @@ -676,7 +676,7 @@ def test_function_name_collision(self): } """ - user_account = self.mevm.create_account(balance=1000) + user_account = self.mevm.create_account(balance=1000000000) contract_account = self.mevm.solidity_create_contract(source_code, owner=user_account) with self.assertRaises(EthereumError): contract_account.ret(self.mevm.make_symbolic_value()) @@ -700,7 +700,7 @@ def test_check_jumpdest_symbolic_pc(self): } } """, - owner=self.mevm.create_account(balance=1000), + owner=self.mevm.create_account(balance=10000000), ) c.mul(1, 2) @@ -716,7 +716,7 @@ def test_gen_testcase_only_if(self): } } """ - user_account = self.mevm.create_account(balance=1000) + user_account = self.mevm.create_account(balance=10 ** 10) contract_account = self.mevm.solidity_create_contract(source_code, owner=user_account) input_sym = self.mevm.make_symbolic_value() contract_account.f(input_sym) @@ -774,7 +774,7 @@ def test_function_name_with_signature(self): } } """ - user_account = self.mevm.create_account(balance=1000) + user_account = self.mevm.create_account(balance=10 ** 10) contract_account = self.mevm.solidity_create_contract(source_code, owner=user_account) contract_account.ret( self.mevm.make_symbolic_value(), @@ -799,8 +799,8 @@ def test_migrate_integration(self): } """ - owner_account = m.create_account(balance=1000) - attacker_account = m.create_account(balance=1000) + owner_account = m.create_account(balance=10 ** 10) + attacker_account = m.create_account(balance=10 ** 10) contract_account = m.solidity_create_contract(contract_src, owner=owner_account, balance=0) # Some global expression `sym_add1` @@ -847,7 +847,7 @@ def test_account_names(self): def test_regression_internal_tx(self): m = self.mevm - owner_account = m.create_account(balance=1000) + owner_account = m.create_account(balance=10 ** 10) c = """ contract C1 { function g() returns (uint) { @@ -927,19 +927,19 @@ def test_call_with_concretized_args(self): contract_src = """ contract C { function transferHalfTo(address receiver) public payable { - receiver.transfer(this.balance/2); + receiver.transfer(address(this).balance/2); } } """ - owner = m.create_account(balance=10 ** 10) + owner = m.create_account(balance=20 ** 10) contract = m.solidity_create_contract(contract_src, owner=owner) - receiver = m.create_account(0) + receiver = m.create_account(balance=0) symbolic_address = m.make_symbolic_address() m.constrain(symbolic_address == receiver.address) self.assertTrue(m.count_ready_states() > 0) - contract.transferHalfTo(symbolic_address, caller=owner, value=m.make_symbolic_value()) - self.assertTrue(m.count_ready_states() > 0) + contract.transferHalfTo(symbolic_address, caller=owner, value=1000000, gas=9999999999) + self.assertTrue( any( state.can_be_true(state.platform.get_balance(receiver.address) > 0) @@ -1103,13 +1103,16 @@ def test_event_forwarding_after_state_fork_during_message_call(self): m = self.mevm m.register_detector(DetectExternalCallAndLeak()) - owner = m.create_account(name="owner", balance=1000) + owner = m.create_account(name="owner", balance=30000000000000000) wallet = m.solidity_create_contract( - source_code, name="wallet", contract_name="Wallet", owner=owner, balance=1000 + source_code, + name="wallet", + contract_name="Wallet", + owner=owner, + balance=10000000000000000, ) - attacker = m.create_account(name="attacker", balance=0) - - wallet.luckyNumber(m.make_symbolic_value(), caller=attacker) + attacker = m.create_account(name="attacker", balance=30000000000000000) + wallet.luckyNumber(m.make_symbolic_value(), caller=attacker, gas=2312312312222) m.finalize() self.assertListEqual([x[2] for x in m.global_findings], ["Reachable ether leak to sender"]) @@ -1131,7 +1134,7 @@ def test_graceful_handle_no_alive_states(self): """ # Initiate the accounts - user_account = m.create_account(balance=1000) + user_account = m.create_account(balance=10 ** 10) contract_account = m.solidity_create_contract(source_code, owner=user_account, balance=0) contract_account.f(1) # it works @@ -1293,7 +1296,7 @@ def test_preconstraints(self): """ m: ManticoreEVM = self.mevm - creator_account = m.create_account(balance=1000) + creator_account = m.create_account(balance=10 ** 10) contract_account = m.solidity_create_contract(source_code, owner=creator_account, balance=0) data = m.make_symbolic_buffer(320) @@ -1304,8 +1307,7 @@ def test_preconstraints(self): m.transaction(caller=creator_account, address=contract_account, data=data, value=value) results = [state.platform.all_transactions[-1].result for state in m.all_states] - # The TXERROR indicates a state where the sent value is greater than the senders budget. - self.assertListEqual(sorted(results), ["STOP"] * 2 + ["TXERROR"]) + self.assertListEqual(sorted(results), ["STOP", "STOP"]) def test_plugins_enable(self): # test enable/disable plugin and sync vs contextmanager @@ -1445,7 +1447,7 @@ def test_abi_constructor_and_fallback_items(self): function() public payable {} } """ - user_account = m.create_account(balance=1000, name="user_account") + user_account = m.create_account(balance=100000000000, name="user_account") contract_account = m.solidity_create_contract( source_code, owner=user_account, name="contract_account", args=(0,) ) @@ -1504,7 +1506,7 @@ def test_overloaded_functions_and_events(self): event E(uint, string); } """ - user_account = m.create_account(balance=1000, name="user_account") + user_account = m.create_account(balance=100000000, name="user_account") contract_account = m.solidity_create_contract( source_code, owner=user_account, name="contract_account" ) @@ -1637,7 +1639,7 @@ def test_delegatecall_env(self): PUSH1 0x0 PUSH2 0X0 PUSH32 0x111111111111111111111111111111111111111 - PUSH32 0x10000 + PUSH32 0x100000 DELEGATECALL STOP """ @@ -1660,7 +1662,7 @@ def test_delegatecall_env(self): 0x222222222222222222222222222222222222222, caller=0x333333333333333333333333333333333333333, value=10, - gas=5000000, + gas=50000000, ) try: @@ -1712,11 +1714,13 @@ def test_gas_check(self): world.create_account( address=0x111111111111111111111111111111111111111, code=EVMAsm.assemble(asm_acc) ) - world.create_account(address=0x222222222222222222222222222222222222222) + world.create_account( + address=0x222222222222222222222222222222222222222, balance=10000000000000 + ) world.transaction( 0x111111111111111111111111111111111111111, caller=0x222222222222222222222222222222222222222, - gas=5003, + gas=50030, ) try: while True: @@ -1733,7 +1737,9 @@ def test_selfdestruct(self): m.create_account( address=0x111111111111111111111111111111111111111, code=EVMAsm.assemble(asm_acc) ) - m.create_account(address=0x222222222222222222222222222222222222222) + m.create_account( + address=0x222222222222222222222222222222222222222, balance=1000000000000000000 + ) # Needs eth to pay for the gas. symbolic_data = m.make_symbolic_buffer(320) m.transaction( caller=0x222222222222222222222222222222222222222, @@ -1768,8 +1774,10 @@ def test_FilterFunctions_fallback_function_matching(self): ) # Only matches the fallback function. m.register_plugin(plugin) - creator_account = m.create_account(balance=1000) - contract_account = m.solidity_create_contract(source_code, owner=creator_account) + creator_account = m.create_account(balance=10000000000000) + contract_account = m.solidity_create_contract( + source_code, owner=creator_account, gas=2134322 + ) symbolic_data = m.make_symbolic_buffer(320) m.transaction( @@ -1782,18 +1790,14 @@ def test_FilterFunctions_fallback_function_matching(self): self.assertEqual(len(m.world.all_transactions), 2) # The fallbackCounter value must have been increased by 1. - contract_account.fallbackCounter() - self.assertEqual(len(m.world.all_transactions), 3) - self.assertEqual( - ABI.deserialize("uint", to_constant(m.world.transactions[-1].return_data)), 123 + 1 - ) - - # The otherCounter value must not have changed. - contract_account.otherCounter() - self.assertEqual(len(m.world.all_transactions), 4) - self.assertEqual( - ABI.deserialize("uint", to_constant(m.world.transactions[-1].return_data)), 456 - ) + self.assertEqual(m.count_ready_states(), 1) + for st in m.ready_states: + world = st.platform + self.assertEqual(len(st.platform.all_transactions), 2) + self.assertTrue( + st.must_be_true(world.get_storage_data(contract_account, 0) == 124) + ) # 123 + 1 + self.assertTrue(st.must_be_true(world.get_storage_data(contract_account, 1) == 456)) def test_checkpoint(self): # test enable/disable plugin and sync vs contextmanager @@ -1821,21 +1825,22 @@ def test_checkpoint(self): value = m.make_symbolic_value() m.transaction(caller=creator_account, address=contract_account, data=data, value=value) self.assertEqual(m.count_ready_states(), 2) - self.assertEqual(m.count_terminated_states(), 2) + self.assertEqual(m.count_terminated_states(), 1) m.goto_snapshot() # return to have only 1 ready state. (The terminated states remain) self.assertEqual(m.count_ready_states(), 1) - self.assertEqual(m.count_terminated_states(), 2) + self.assertEqual(m.count_terminated_states(), 1) data = m.make_symbolic_buffer(320) value = m.make_symbolic_value() m.transaction(caller=creator_account, address=contract_account, data=data, value=value) self.assertEqual(m.count_ready_states(), 2) + self.assertEqual(m.count_terminated_states(), 2) m.clear_snapshot() # Can not go to unexistant snapshot self.assertRaises(Exception, m.goto_snapshot) - self.assertEqual(m.count_terminated_states(), 4) + self.assertEqual(m.count_terminated_states(), 2) m.clear_terminated_states() self.assertEqual(m.count_terminated_states(), 0) diff --git a/tests/ethereum/test_regressions.py b/tests/ethereum/test_regressions.py index 67c6830fd..26ba1c5d0 100644 --- a/tests/ethereum/test_regressions.py +++ b/tests/ethereum/test_regressions.py @@ -273,7 +273,7 @@ def test_addmod(self): caller = 0x42424242424242424242 value = 0 bytecode = "" - vm = evm.EVM(constraints, address, data, caller, value, bytecode) + vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=23000) self.assertEqual(vm.ADDMOD(12323, 2343, 20), 6) self.assertEqual(vm.ADDMOD(12323, 2343, 0), 0) @@ -330,7 +330,7 @@ def test_mulmod(self): caller = 0x42424242424242424242 value = 0 bytecode = "" - vm = evm.EVM(constraints, address, data, caller, value, bytecode) + vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=23000) self.assertEqual(vm.MULMOD(12323, 2343, 20), 9) self.assertEqual(vm.MULMOD(12323, 2343, 0), 0) diff --git a/tests/ethereum/test_sha3.py b/tests/ethereum/test_sha3.py index c0d9ef048..1791ac1e1 100644 --- a/tests/ethereum/test_sha3.py +++ b/tests/ethereum/test_sha3.py @@ -47,8 +47,8 @@ def test_example1(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") symbolic_input = m.make_symbolic_value() @@ -77,8 +77,8 @@ def test_example2(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -108,8 +108,8 @@ def test_example3(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -143,8 +143,8 @@ def test_example4(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -180,8 +180,8 @@ def test_example5(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -216,8 +216,8 @@ def test_example6(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -253,8 +253,8 @@ def test_example7(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -290,8 +290,8 @@ def test_example8(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -326,8 +326,8 @@ def test_essence1(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_buffer(3) @@ -360,8 +360,8 @@ def test_essence2(self): """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_buffer(3) @@ -397,8 +397,8 @@ def test_essence3(self): m = self.ManticoreEVM() m.register_plugin(KeepOnlyIfStorageChanges()) - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x1 = m.make_symbolic_value() @@ -449,8 +449,8 @@ def test_example_concrete_1(self): } """ m = self.ManticoreEVM() - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x = m.make_symbolic_value() @@ -504,8 +504,8 @@ def test_essence3(self): m = self.ManticoreEVM() m.register_plugin(KeepOnlyIfStorageChanges()) - owner = m.create_account(balance=1000, name="owner") - attacker = m.create_account(balance=1000, name="attacker") + owner = m.create_account(balance=10000000, name="owner") + attacker = m.create_account(balance=10000000, name="attacker") contract = m.solidity_create_contract(source_code, owner=owner, name="contract") x1 = m.make_symbolic_value() diff --git a/tests/ethereum_bench/test_consensys_benchmark.py b/tests/ethereum_bench/test_consensys_benchmark.py index 3f288a1ee..b6a9fe9cd 100644 --- a/tests/ethereum_bench/test_consensys_benchmark.py +++ b/tests/ethereum_bench/test_consensys_benchmark.py @@ -14,6 +14,11 @@ THIS_DIR = os.path.dirname(os.path.abspath(__file__)) +from manticore.utils import config + +config.get_group("evm").oog = "ignore" +config.get_group("core").mprocessing = "single" + class EthBenchmark(unittest.TestCase): """ https://consensys.net/diligence/evm-analyzer-benchmark-suite/ """ @@ -168,3 +173,7 @@ def test_reentrancy_dao(self): def test_eth_tx_order_dependence_multitx_1(self): name = inspect.currentframe().f_code.co_name[5:] self._test(name, set()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/ethereum_vm/VMTests_concrete/__init__.py b/tests/ethereum_vm/VMTests_concrete/__init__.py deleted file mode 100644 index 3755e783b..000000000 --- a/tests/ethereum_vm/VMTests_concrete/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# DO NOT DELETE diff --git a/tests/ethereum_vm/VMTests_symbolic/__init__.py b/tests/ethereum_vm/VMTests_symbolic/__init__.py deleted file mode 100644 index 3755e783b..000000000 --- a/tests/ethereum_vm/VMTests_symbolic/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# DO NOT DELETE diff --git a/tests/native/test_memory.py b/tests/native/test_memory.py index e6f03ea70..7743644eb 100644 --- a/tests/native/test_memory.py +++ b/tests/native/test_memory.py @@ -1423,15 +1423,18 @@ def testmprotectFailSymbReading(self): sol = solver.get_value(cs, x) # it should comply... self.assertTrue(sol >= addr and sol <= addr + 0x2000) - # print map(hex,sorted(solver.get_all_values(cs, x, 0x100000))), map(hex,solver.minmax(cs, x)), mem[x] - # No Access Reading <4160741376> - # self.assertRaisesRegexp(MemoryException, r"No access reading.*", mem.__getitem__, x) - with self.assertRaisesRegex( - InvalidSymbolicMemoryAccess, r"Invalid symbolic memory access \(mode:r\)" - ): - _ = mem[x] - # mem[addr] = 'a' + # this could crash OR not + native_config = config.get_group("native") + with native_config.temp_vals(): + native_config.fast_crash = True + # No Access Reading <4160741376> + # self.assertRaisesRegexp(MemoryException, r"No access reading.*", mem.__getitem__, x) + with self.assertRaisesRegex( + InvalidSymbolicMemoryAccess, r"Invalid symbolic memory access \(mode:r\)" + ): + _ = mem[x] + # mem[addr] = 'a' def testmprotectFailWriting(self): mem = Memory32() diff --git a/tests/other/test_smtlibv2.py b/tests/other/test_smtlibv2.py index c9b230fdf..2a93d8648 100644 --- a/tests/other/test_smtlibv2.py +++ b/tests/other/test_smtlibv2.py @@ -43,6 +43,13 @@ def test_no_variable_expression_can_be_true(self): cs = ConstraintSet() self.assertFalse(self.solver.can_be_true(cs, x == False)) + def test_constant_bitvec(self): + """ + Tests if higher bits are masked out + """ + x = BitVecConstant(32, 0xFF00000000) + self.assertTrue(x.value == 0) + def testBasicAST_001(self): """ Can't build abstract classes """ a = BitVecConstant(32, 100) From 7f5f12c5a7e92984cca761289611bb94b14e4fdf Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 9 Jun 2020 11:37:38 -0300 Subject: [PATCH 08/28] Fix default output space when workspace is in mem: (#1724) --- manticore/core/manticore.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index 68b8bb4d2..c2e0b47a8 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -353,6 +353,8 @@ def __init__(self, initial_state, workspace_url=None, outputspace_url=None, **kw raise TypeError(f"Invalid workspace type: {type(workspace_url).__name__}") self._workspace = Workspace(workspace_url) # reuse the same workspace if not specified + if outputspace_url is None: + outputspace_url = workspace_url if outputspace_url is None: outputspace_url = f"fs:{self._workspace.uri}" self._output = ManticoreOutput(outputspace_url) From ddec477dbdf946cb631693d6a0d355bfeac430ac Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 9 Jun 2020 16:16:18 -0300 Subject: [PATCH 09/28] Rollback to support yices again (#1714) * Rollback to support yices again * CC * Test yices * Better get-value handling * Z3/CVC4/YICES * CC * Yices/CVC4 * CC * Default yices * Default debug level fix * Quick auto solver * shutil.which * CC * Default yices for testing * Remove old commented out code * Update manticore/core/smtlib/solver.py Co-authored-by: Eric Kilmer * Update manticore/core/smtlib/solver.py Co-authored-by: Eric Kilmer * Remove unused class * Update manticore/core/smtlib/solver.py Co-authored-by: Eric Kilmer * Update manticore/core/smtlib/solver.py Co-authored-by: Eric Kilmer * Readme hack * CC/lint * Fix typing * z3 back to the rodeo * lint * Fancy optimize * Fix lint * CC reviewed Co-authored-by: Eric Kilmer --- .github/workflows/ci.yml | 7 + README.md | 17 + manticore/core/smtlib/expression.py | 4 + manticore/core/smtlib/solver.py | 723 +++++++++++++++------------- manticore/core/state.py | 4 +- manticore/core/workspace.py | 4 +- manticore/ethereum/manticore.py | 6 +- manticore/native/cpu/abstractcpu.py | 4 +- manticore/native/manticore.py | 4 +- manticore/native/memory.py | 10 +- manticore/native/models.py | 4 +- manticore/native/state_merging.py | 20 +- manticore/platforms/evm.py | 16 +- manticore/platforms/linux.py | 10 +- manticore/utils/config.py | 11 + manticore/utils/emulate.py | 6 +- manticore/wasm/manticore.py | 10 +- manticore/wasm/structure.py | 4 +- tests/other/test_smtlibv2.py | 70 ++- 19 files changed, 540 insertions(+), 394 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f13c2e275..8aa622fff 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -51,6 +51,13 @@ jobs: env: TEST_TYPE: ${{ matrix.type }} run: | + #install cvc4 + sudo wget -O /usr/bin/cvc4 https://github.com/CVC4/CVC4/releases/download/1.7/cvc4-1.7-x86_64-linux-opt + sudo chmod +x /usr/bin/cvc4 + #install yices + sudo add-apt-repository ppa:sri-csl/formal-methods + sudo apt-get update + sudo apt-get install yices2 # Install solc unconditionally because it only takes a second or two sudo wget -O /usr/bin/solc https://github.com/ethereum/solidity/releases/download/v0.4.24/solc-static-linux sudo chmod +x /usr/bin/solc diff --git a/README.md b/README.md index 3f95e1ca3..bc65bb997 100644 --- a/README.md +++ b/README.md @@ -216,6 +216,23 @@ for idx, val_list in enumerate(m.collect_returns()): * We're still in the process of implementing full support for the EVM Istanbul instruction semantics, so certain opcodes may not be supported. In a pinch, you can try compiling with Solidity 0.4.x to avoid generating those instructions. +## Using a different solverr (Z3, Yices, CVC4) +Manticore relies on an external solver supporting smtlib2. Curently Z3, Yices and CVC4 are supported and can be selected via commandline or configuration settings. +By default Manticore will use Z3. Once you installed a different solver you can choose a different solver like this: +```manticore --smt.solver yices``` +### Installing CVC4 +For more details go to https://cvc4.github.io/. Otherwise just get the binary and use it. + + sudo wget -O /usr/bin/cvc4 https://github.com/CVC4/CVC4/releases/download/1.7/cvc4-1.7-x86_64-linux-opt + sudo chmod +x /usr/bin/cvc4 + +### Installing Yices +Yices is incredibly fast. More details here https://yices.csl.sri.com/ + + sudo add-apt-repository ppa:sri-csl/formal-methods + sudo apt-get update + sudo apt-get install yices2 + ## Getting Help Feel free to stop by our #manticore slack channel in [Empire Hacking](https://empireslacking.herokuapp.com/) for help using or extending Manticore. diff --git a/manticore/core/smtlib/expression.py b/manticore/core/smtlib/expression.py index 60ea896f6..7e964ad8a 100644 --- a/manticore/core/smtlib/expression.py +++ b/manticore/core/smtlib/expression.py @@ -777,6 +777,10 @@ def __getitem__(self, index): raise IndexError return self.select(self.cast_index(index)) + def __iter__(self): + for i in range(len(self)): + yield self[i] + def __eq__(self, other): # FIXME taint def compare_buffers(a, b): diff --git a/manticore/core/smtlib/solver.py b/manticore/core/smtlib/solver.py index f389a186f..365b83a0e 100644 --- a/manticore/core/smtlib/solver.py +++ b/manticore/core/smtlib/solver.py @@ -13,14 +13,17 @@ # Once you Solver.check() it the status is changed to sat or unsat (or unknown+exception) # You can create new symbols operate on them. The declarations will be sent to the smtlib process when needed. # You can add new constraints. A new constraint may change the state from {None, sat} to {sat, unsat, unknown} + import os +import shutil import threading +from queue import Queue import collections import shlex import time from functools import lru_cache -from typing import Dict, Tuple -from subprocess import PIPE, Popen +from typing import Dict, Tuple, Sequence, Optional +from subprocess import PIPE, Popen, check_output import re from . import operators as Operators from .constraints import * @@ -30,6 +33,16 @@ from ...utils.resources import check_memory_usage, check_disk_usage from . import issymbolic + +class SolverType(config.ConfigEnum): + """Used as configuration constant for choosing solver flavor""" + + z3 = "z3" + cvc4 = "cvc4" + yices = "yices" + auto = "auto" + + logger = logging.getLogger(__name__) consts = config.get_group("smt") consts.add("timeout", default=120, description="Timeout, in seconds, for each Z3 invocation") @@ -39,15 +52,26 @@ default=10000, description="Maximum solutions to provide when solving for all values", ) -consts.add("z3_bin", default="z3", description="Z3 binary to use") +consts.add("z3_bin", default="z3", description="Z3 solver binary to use") +consts.add("cvc4_bin", default="cvc4", description="CVC4 solver binary to use") +consts.add("yices_bin", default="yices-smt2", description="Yices solver binary to use") + + consts.add("defaultunsat", default=True, description="Consider solver timeouts as unsat core") consts.add( "optimize", default=True, description="Use smtlib command optimize to find min/max if available" ) +consts.add( + "solver", + default=SolverType.z3, + description="Choose default smtlib2 solver (z3, yices, cvc4, auto)", +) # Regular expressions used by the solver -RE_GET_EXPR_VALUE_FMT = re.compile(r"\(\((?P(.*))\ #x(?P([0-9a-fA-F]*))\)\)") +RE_GET_EXPR_VALUE_FMT_BIN = re.compile(r"\(\((?P(.*))[ \n\s]*#b(?P([0-1]*))\)\)") +RE_GET_EXPR_VALUE_FMT_DEC = re.compile(r"\(\((?P(.*))\ \(_\ bv(?P(\d*))\ \d*\)\)\)") +RE_GET_EXPR_VALUE_FMT_HEX = re.compile(r"\(\((?P(.*))\ #x(?P([0-9a-fA-F]*))\)\)") RE_OBJECTIVES_EXPR_VALUE = re.compile( r"\(objectives.*\((?P.*) (?P\d*)\).*\).*", re.MULTILINE | re.DOTALL ) @@ -143,206 +167,163 @@ def minmax(self, constraints, x, iters=10000): Version = collections.namedtuple("Version", "major minor patch") -class Z3Solver(Solver): - def __init__(self): - """ - Build a Z3 solver instance. - This is implemented using an external z3 solver (via a subprocess). - See https://github.com/Z3Prover/z3 - """ - super().__init__() - self._proc: Popen = None - - self._command = ( - f"{consts.z3_bin} -t:{consts.timeout*1000} -memory:{consts.memory} -smt2 -in" - ) - - # Commands used to initialize z3 - self._init = [ - # http://smtlib.cs.uiowa.edu/logics-all.shtml#QF_AUFBV - # Closed quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with - # free sort and function symbols. - "(set-logic QF_AUFBV)", - # The declarations and definitions will be scoped - "(set-option :global-decls false)", - # sam.moelius: Option "tactic.solve_eqs.context_solve" was turned on by this commit in z3: - # https://github.com/Z3Prover/z3/commit/3e53b6f2dbbd09380cd11706cabbc7e14b0cc6a2 - # Turning it off greatly improves Manticore's performance on test_integer_overflow_storageinvariant - # in test_consensys_benchmark.py. - "(set-option :tactic.solve_eqs.context_solve false)", - ] - - self._get_value_fmt = (RE_GET_EXPR_VALUE_FMT, 16) - - self.debug = False - # To cache what get-info returned; can be directly set when writing tests - self._received_version = None - self.version = self._solver_version() +class SmtlibProc: + def __init__(self, command: str, debug: bool = False): + """ Single smtlib interactive process - self.support_maximize = False - self.support_minimize = False - self.support_reset = True - logger.debug("Z3 version: %s", self.version) - - if self.version >= Version(4, 5, 0): - self.support_maximize = False - self.support_minimize = False - self.support_reset = False - elif self.version >= Version(4, 4, 1): - self.support_maximize = True - self.support_minimize = True - self.support_reset = False - else: - logger.debug(" Please install Z3 4.4.1 or newer to get optimization support") - - def _solver_version(self) -> Version: + :param command: the shell command to execute + :param debug: log all messaging """ - If we fail to parse the version, we assume z3's output has changed, meaning it's a newer - version than what's used now, and therefore ok. - - Anticipated version_cmd_output format: 'Z3 version 4.4.2' - 'Z3 version 4.4.5 - 64 bit - build hashcode $Z3GITHASH' - """ - self._reset() - if self._received_version is None: - self._send("(get-info :version)") - self._received_version = self._recv() - key, version = shlex.split(self._received_version[1:-1]) - try: - parsed_version = Version(*map(int, version.split(" ", 1)[0].split("."))) - except (ValueError, TypeError) as e: - logger.warning(f"Could not parse Z3 version: '{version}'. Assuming compatibility.") - parsed_version = Version(float("inf"), float("inf"), float("inf")) - return parsed_version + self._proc: Optional[Popen] = None + self._command = command + self._debug = debug - def _start_proc(self): - """Spawns z3 solver process""" - assert "_proc" not in dir(self) or self._proc is None - try: - self._proc = Popen( - shlex.split(self._command), - stdin=PIPE, - stdout=PIPE, - bufsize=0, - universal_newlines=True, - close_fds=True, - ) - except OSError as e: - print(e, "Probably too many cached expressions? visitors._cache...") - # Z3 was removed from the system in the middle of operation - raise Z3NotFoundError # TODO(mark) don't catch this exception in two places - - # run solver specific initializations - for cfg in self._init: - self._send(cfg) + def start(self): + """Spawns POpen solver process""" + if self._proc is not None: + return + self._proc = Popen( + shlex.split(self._command), + stdin=PIPE, + stdout=PIPE, + bufsize=0, + universal_newlines=True, + close_fds=True, + ) - def _stop_proc(self): + def stop(self): """ - Stops the z3 solver process by: - - sending an exit command to it, + Stops the solver process by: - sending a SIGKILL signal, - waiting till the process terminates (so we don't leave a zombie process) """ if self._proc is None: return + # if it did not finished already if self._proc.returncode is None: - try: - self._send("(exit)") - except (SolverError, IOError) as e: - # z3 was too fast to close - logger.debug(str(e)) - finally: - try: - self._proc.stdin.close() - except IOError as e: - logger.debug(str(e)) - try: - self._proc.stdout.close() - except IOError as e: - logger.debug(str(e)) - self._proc.kill() - # Wait for termination, to avoid zombies. - self._proc.wait() - - self._proc: Popen = None - - # marshaling/pickle - def __getstate__(self): - raise SolverException() - - def __setstate__(self, state): - raise SolverException() - - def __del__(self): - try: - if self._proc is not None: - self._stop_proc() - # self._proc.stdin.writelines(('(exit)\n',)) - # self._proc.wait() - except Exception as e: - logger.error(str(e)) - - def _reset(self, constraints: Optional[str] = None) -> None: - """Auxiliary method to reset the smtlib external solver to initial defaults""" - if self._proc is None: - self._start_proc() - else: - if self.support_reset: - self._send("(reset)") - - for cfg in self._init: - self._send(cfg) - else: - self._stop_proc() - self._start_proc() - if constraints is not None: - self._send(constraints) - - def _send(self, cmd: str) -> None: + self._proc.stdin.close() + self._proc.stdout.close() + # Kill the process + self._proc.kill() + # No need to wait for termination, zombies avoided. + self._proc = None + + def __readline_and_count(self): + assert self._proc + assert self._proc.stdout + buf = self._proc.stdout.readline() # No timeout enforced here + # If debug is enabled check if the solver reports a syntax error + # Error messages may contain an unbalanced parenthesis situation + if self._debug: + if "(error" in buf: + raise SolverException(f"Error in smtlib: {buf}") + # lparen, rparen = buf.count("("), buf.count(")") + lparen, rparen = map(sum, zip(*((c == "(", c == ")") for c in buf))) + return buf, lparen, rparen + + def send(self, cmd: str) -> None: """ Send a string to the solver. :param cmd: a SMTLIBv2 command (ex. (check-sat)) """ - # logger.debug('>%s', cmd) - try: - if self._proc.stdout: - self._proc.stdout.flush() - else: - raise SolverError("Could not flush stdout: file descriptor is None") - if self._proc.stdin: - self._proc.stdin.write(f"{cmd}\n") - else: - raise SolverError("Could not write to stdin: file descriptor is None") - except IOError as e: - raise SolverError(str(e)) - - def _recv(self) -> str: - """Reads the response from the solver""" + if self._debug: + logger.debug(">%s", cmd) + print(">", cmd) + self._proc.stdout.flush() # type: ignore + self._proc.stdin.write(f"{cmd}\n") # type: ignore + + def recv(self) -> str: + """Reads the response from the smtlib solver""" buf, left, right = self.__readline_and_count() bufl = [buf] - while left != right: buf, l, r = self.__readline_and_count() bufl.append(buf) left += l right += r - if "(error" in bufl[0]: - raise SolverException(f"Error in smtlib: {bufl[0]}") buf = "".join(bufl).strip() - if "(error" in bufl[0]: - raise SolverException(f"Error in smtlib: {bufl[0]}") + + if self._debug: + logger.debug("<%s", buf) + print("<", buf) + return buf - def __readline_and_count(self) -> Tuple[str, int, int]: - stdout = self._proc.stdout - if stdout is None: - raise SolverError("Could not read from stdout: file descriptor is None") - buf = stdout.readline() - if buf is None: - raise SolverError("Could not read from stdout") - return buf, buf.count("("), buf.count(")") + def _restart(self) -> None: + """Auxiliary to start or restart the external solver""" + self.stop() + self.start() + + def is_started(self): + return self._proc is not None + + +class SMTLIBSolver(Solver): + def __init__( + self, + command: str, + init: Sequence[str] = None, + value_fmt: int = 16, + support_reset: bool = False, + support_minmax: bool = False, + support_pushpop: bool = False, + debug: bool = False, + ): + + """ + Build a smtlib solver instance. + This is implemented using an external solver (via a subprocess). + """ + super().__init__() + self._smtlib: SmtlibProc = SmtlibProc(command, debug) + + # Commands used to initialize smtlib + if init is None: + init = tuple() + self._init = init + self._get_value_fmt = ( + { + 2: RE_GET_EXPR_VALUE_FMT_BIN, + 10: RE_GET_EXPR_VALUE_FMT_DEC, + 16: RE_GET_EXPR_VALUE_FMT_HEX, + }[value_fmt], + value_fmt, + ) + + self._support_minmax = support_minmax + self._support_reset = support_reset + self._support_pushpop = support_pushpop + + if not self._support_pushpop: + setattr(self, "_push", None) + setattr(self, "_pop", None) + + if self._support_minmax and consts.optimize: + setattr(self, "optimize", self._optimize_fancy) + else: + setattr(self, "optimize", self._optimize_generic) + + self._smtlib.start() + # run solver specific initializations + for cfg in self._init: + self._smtlib.send(cfg) + + def _reset(self, constraints: Optional[str] = None) -> None: + """Auxiliary method to reset the smtlib external solver to initial defaults""" + if self._support_reset: + self._smtlib.start() # does not do anything if already started + self._smtlib.send("(reset)") + else: + self._smtlib.stop() # does not do anything if already stopped + self._smtlib.start() + + for cfg in self._init: + self._smtlib.send(cfg) + + if constraints is not None: + self._smtlib.send(constraints) # UTILS: check-sat get-value def _is_sat(self) -> bool: @@ -351,10 +332,9 @@ def _is_sat(self) -> bool: :return: whether current state is satisfiable or not. """ - logger.debug("Solver.check() ") start = time.time() - self._send("(check-sat)") - status = self._recv() + self._smtlib.send("(check-sat)") + status = self._smtlib.recv() logger.debug("Check took %s seconds (%s)", time.time() - start, status) if status not in ("sat", "unsat", "unknown"): raise SolverError(status) @@ -362,23 +342,28 @@ def _is_sat(self) -> bool: if status == "unknown": logger.info("Found an unknown core, probably a solver timeout") status = "unsat" - if status == "unknown": raise SolverUnknown(status) - - is_sat = status == "sat" - if not is_sat: - check_memory_usage() - check_disk_usage() - return is_sat + return status == "sat" def _assert(self, expression: Bool): """Auxiliary method to send an assert""" - assert isinstance(expression, Bool) smtlib = translate_to_smtlib(expression) - self._send("(assert %s)" % smtlib) + self._smtlib.send(f"(assert {smtlib})") + + def __getvalue_bv(self, expression_str: str) -> int: + self._smtlib.send(f"(get-value ({expression_str}))") + pattern, base = self._get_value_fmt + m = pattern.match(self._smtlib.recv()) + expr, value = m.group("expr"), m.group("value") # type: ignore + return int(value, base) - def _getvalue(self, expression): + def __getvalue_bool(self, expression_str): + self._smtlib.send(f"(get-value ({expression_str}))") + ret = self._smtlib.recv() + return {"true": True, "false": False}[ret[2:-2].split(" ")[1]] + + def _getvalue(self, expression) -> Union[int, bool, bytes]: """ Ask the solver for one possible assignment for given expression using current set of constraints. The current set of expressions must be sat. @@ -387,39 +372,31 @@ def _getvalue(self, expression): """ if not issymbolic(expression): return expression - assert isinstance(expression, Variable) if isinstance(expression, Array): result = bytearray() for c in expression: expression_str = translate_to_smtlib(c) - self._send("(get-value (%s))" % expression_str) - response = self._recv() - result.append(int("0x{:s}".format(response.split(expression_str)[1][3:-2]), 16)) + result.append(self.__getvalue_bv(expression_str)) return bytes(result) else: - self._send("(get-value (%s))" % expression.name) - ret = self._recv() - assert ret.startswith("((") and ret.endswith("))"), ret + if isinstance(expression, BoolVariable): + return self.__getvalue_bool(expression.name) + elif isinstance(expression, BitVecVariable): + return self.__getvalue_bv(expression.name) - if isinstance(expression, Bool): - return {"true": True, "false": False}[ret[2:-2].split(" ")[1]] - elif isinstance(expression, BitVec): - pattern, base = self._get_value_fmt - m = pattern.match(ret) - expr, value = m.group("expr"), m.group("value") - return int(value, base) - - raise NotImplementedError("_getvalue only implemented for Bool and BitVec") + raise NotImplementedError( + f"_getvalue only implemented for Bool, BitVec and Array. Got {type(expression)}" + ) # push pop def _push(self): """Pushes and save the current constraint store and state.""" - self._send("(push 1)") + self._smtlib.send("(push 1)") def _pop(self): """Recall the last pushed constraint store and state.""" - self._send("(pop 1)") + self._smtlib.send("(pop 1)") @lru_cache(maxsize=32) def can_be_true(self, constraints: ConstraintSet, expression: Union[bool, Bool] = True) -> bool: @@ -431,20 +408,99 @@ def can_be_true(self, constraints: ConstraintSet, expression: Union[bool, Bool] # if True check if constraints are feasible self._reset(constraints.to_string()) return self._is_sat() - assert isinstance(expression, Bool) with constraints as temp_cs: temp_cs.add(expression) - self._reset(temp_cs.to_string(related_to=expression)) - return self._is_sat() + return self.can_be_true(temp_cs) # get-all-values min max minmax + def _optimize_generic(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10000): + """ + Iteratively finds the maximum or minimum value for the operation + (Normally Operators.UGT or Operators.ULT) + + :param constraints: constraints to take into account + :param x: a symbol or expression + :param goal: goal to achieve, either 'maximize' or 'minimize' + :param max_iter: maximum number of iterations allowed + """ + # TODO: consider adding a mode to return best known value on timeout + assert goal in ("maximize", "minimize") + operation = {"maximize": Operators.UGE, "minimize": Operators.ULE}[goal] + + last_value: Optional[Union[int, bool, bytes]] = None + + start = time.time() + with constraints as temp_cs: + X = temp_cs.new_bitvec(x.size) + temp_cs.add(X == x) + aux = temp_cs.new_bitvec(X.size, name="optimized_") + self._reset(temp_cs.to_string(related_to=X)) + + # Find one value and use it as currently known min/Max + if not self._is_sat(): + raise SolverException("UNSAT") + last_value = self._getvalue(X) + self._assert(operation(X, last_value)) + + # This uses a binary search to find a suitable range for aux + # Use known solution as min or max depending on the goal + if goal == "maximize": + m, M = last_value, (1 << x.size) - 1 + else: + m, M = 0, last_value + + # Iteratively divide the range + L = None + while L not in (M, m): + L = (m + M) // 2 + self._assert(operation(X, L)) + sat = self._is_sat() + + # depending on the goal move one of the extremes + if goal == "maximize" and sat or goal == "minimize" and not sat: + m = L + else: + M = L + + if time.time() - start > consts.timeout: + raise SolverError("Timeout") + + # reset to before the dichotomic search + self._reset(temp_cs.to_string(related_to=X)) + + # At this point we know aux is inside [m,M] + # Lets constrain it to that range + self._assert(Operators.UGE(X, m)) + self._assert(Operators.ULE(X, M)) + + # And now check all remaining possible extremes + last_value = None + i = 0 + while self._is_sat(): + last_value = self._getvalue(X) + self._assert(operation(X, last_value)) + self._assert(X != last_value) + i = i + 1 + if i > max_iter: + raise SolverError("Optimizing error, maximum number of iterations was reached") + if time.time() - start > consts.timeout: + raise SolverError("Timeout") + if last_value is not None: + return last_value + raise SolverError("Optimizing error, unsat or unknown core") + @lru_cache(maxsize=32) - def get_all_values(self, constraints, expression, maxcnt=None, silent=False): + def get_all_values( + self, + constraints: ConstraintSet, + expression, + maxcnt: Optional[int] = None, + silent: bool = False, + ): """Returns a list with all the possible values for the symbol x""" if not isinstance(expression, Expression): return [expression] - assert isinstance(constraints, ConstraintSet) assert isinstance(expression, Expression) expression = simplify(expression) if maxcnt is None: @@ -498,7 +554,7 @@ def get_all_values(self, constraints, expression, maxcnt=None, silent=False): # self._assert(var != value) return list(result) - def optimize(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10000): + def _optimize_fancy(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10000): """ Iteratively finds the maximum or minimum value for the operation (Normally Operators.UGT or Operators.ULT) @@ -517,101 +573,15 @@ def optimize(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10 temp_cs.add(X == x) aux = temp_cs.new_bitvec(X.size, name="optimized_") self._reset(temp_cs.to_string(related_to=X)) - self._send(aux.declaration) + self._smtlib.send(aux.declaration) - start = time.time() - if consts.optimize and getattr(self, f"support_{goal}", False): - self._push() - try: - self._assert(operation(X, aux)) - self._send("(%s %s)" % (goal, aux.name)) - self._send("(check-sat)") - _status = self._recv() - if _status not in ("sat", "unsat", "unknown"): - # Minimize (or Maximize) sometimes prints the objective before the status - # This will be a line like NAME |-> VALUE - maybe_sat = self._recv() - if maybe_sat == "sat": - match = RE_MIN_MAX_OBJECTIVE_EXPR_VALUE.match(_status) - if match: - expr, value = match.group("expr"), match.group("value") - assert expr == aux.name - return int(value) - else: - raise SolverError("Could not match MinMax objective value regex") - elif _status == "sat": - ret = self._recv() - if not (ret.startswith("(") and ret.endswith(")")): - raise SolverError("bad output on max, z3 may have been killed") - - match = RE_OBJECTIVES_EXPR_VALUE.match(ret) - if match: - expr, value = match.group("expr"), match.group("value") - assert expr == aux.name - return int(value) - else: - raise SolverError("Could not match objective value regex") - finally: - self._pop() - self._reset(temp_cs.to_string()) - self._send(aux.declaration) - - operation = {"maximize": Operators.UGE, "minimize": Operators.ULE}[goal] - self._assert(aux == X) - - # Find one value and use it as currently known min/Max - if not self._is_sat(): - raise SolverException("UNSAT") - last_value = self._getvalue(aux) - self._assert(operation(aux, last_value)) - - # This uses a binary search to find a suitable range for aux - # Use known solution as min or max depending on the goal - if goal == "maximize": - m, M = last_value, (1 << x.size) - 1 - else: - m, M = 0, last_value - - # Iteratively divide the range - L = None - while L not in (M, m): - L = (m + M) // 2 - self._push() - try: - self._assert(operation(aux, L)) - sat = self._is_sat() - finally: - self._pop() - - # depending on the goal move one of the extremes - if goal == "maximize" and sat or goal == "minimize" and not sat: - m = L - else: - M = L - - if time.time() - start > consts.timeout: - raise SolverError("Timeout") - - # At this point we know aux is inside [m,M] - # Lets constrain it to that range - self._assert(Operators.UGE(aux, m)) - self._assert(Operators.ULE(aux, M)) - - # And now check all remaining possible extremes - last_value = None - i = 0 - while self._is_sat(): - last_value = self._getvalue(aux) - self._assert(operation(aux, last_value)) - self._assert(aux != last_value) - i = i + 1 - if i > max_iter: - raise SolverError("Optimizing error, maximum number of iterations was reached") - if time.time() - start > consts.timeout: - raise SolverError("Timeout") - if last_value is not None: - return last_value - raise SolverError("Optimizing error, unsat or unknown core") + self._assert(operation(X, aux)) + self._smtlib.send("(%s %s)" % (goal, aux.name)) + self._smtlib.send("(check-sat)") + _status = self._smtlib.recv() + if _status == "sat": + return self._getvalue(aux) + raise SolverError("Optimize failed") def get_value(self, constraints: ConstraintSet, *expressions): """ @@ -645,13 +615,7 @@ def get_value(self, constraints: ConstraintSet, *expressions): ) for i in range(expression.index_max): - self._send("(get-value (%s))" % var[i].name) - ret = self._recv() - assert ret.startswith("((") and ret.endswith("))") - pattern, base = self._get_value_fmt - m = pattern.match(ret) - expr, value = m.group("expr"), m.group("value") - result.append(int(value, base)) + result.append(self.__getvalue_bv(var[i].name)) values.append(bytes(result)) if time.time() - start > consts.timeout: raise SolverError("Timeout") @@ -666,18 +630,10 @@ def get_value(self, constraints: ConstraintSet, *expressions): "Solver could not find a value for expression under current constraint set" ) - self._send("(get-value (%s))" % var.name) - ret = self._recv() - if not (ret.startswith("((") and ret.endswith("))")): - raise SolverError("SMTLIB error parsing response: %s" % ret) - if isinstance(expression, Bool): - values.append({"true": True, "false": False}[ret[2:-2].split(" ")[1]]) + values.append(self.__getvalue_bool(var.name)) if isinstance(expression, BitVec): - pattern, base = self._get_value_fmt - m = pattern.match(ret) - expr, value = m.group("expr"), m.group("value") - values.append(int(value, base)) + values.append(self.__getvalue_bv(var.name)) if time.time() - start > consts.timeout: raise SolverError("Timeout") @@ -685,3 +641,120 @@ def get_value(self, constraints: ConstraintSet, *expressions): return values[0] else: return values + + +class Z3Solver(SMTLIBSolver): + def __init__(self): + """ + Build a Z3 solver instance. + This is implemented using an external z3 solver (via a subprocess). + See https://github.com/Z3Prover/z3 + """ + init = [ + # http://smtlib.cs.uiowa.edu/logics-all.shtml#QF_AUFBV + # Closed quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with + # free sort and function symbols. + "(set-logic QF_AUFBV)", + # The declarations and definitions will be scoped + "(set-option :global-decls false)", + # sam.moelius: Option "tactic.solve_eqs.context_solve" was turned on by this commit in z3: + # https://github.com/Z3Prover/z3/commit/3e53b6f2dbbd09380cd11706cabbc7e14b0cc6a2 + # Turning it off greatly improves Manticore's performance on test_integer_overflow_storageinvariant + # in test_consensys_benchmark.py. + "(set-option :tactic.solve_eqs.context_solve false)", + ] + command = f"{consts.z3_bin} -t:{consts.timeout * 1000} -memory:{consts.memory} -smt2 -in" + + support_minmax, support_reset = self.__autoconfig() + super().__init__( + command=command, + init=init, + value_fmt=16, + support_minmax=True, + support_reset=True, + support_pushpop=True, + debug=False, + ) + + def __autoconfig(self): + # To cache what get-info returned; can be directly set when writing tests + self.version = self._solver_version() + if self.version >= Version(4, 5, 0): + support_minmax = False + support_reset = False + elif self.version >= Version(4, 4, 1): + support_minmax = True + support_reset = False + else: + logger.debug(" Please install Z3 4.4.1 or newer to get optimization support") + return support_minmax, support_reset + + def _solver_version(self) -> Version: + """ + If we fail to parse the version, we assume z3's output has changed, meaning it's a newer + version than what's used now, and therefore ok. + + Anticipated version_cmd_output format: 'Z3 version 4.4.2' + 'Z3 version 4.4.5 - 64 bit - build hashcode $Z3GITHASH' + """ + try: + received_version = check_output([f"{consts.z3_bin}", "--version"]) + Z3VERSION = re.compile( + r".*(?P([0-9]+))\.(?P([0-9]+))\.(?P([0-9]+)).*" + ) + m = Z3VERSION.match(received_version.decode("utf-8")) + major, minor, patch = map( + int, (m.group("major"), m.group("minor"), m.group("patch")) # type: ignore + ) + parsed_version = Version(major, minor, patch) + except (ValueError, TypeError) as e: + logger.warning( + f"Could not parse Z3 version: '{str(received_version)}'. Assuming compatibility." + ) + parsed_version = Version(float("inf"), float("inf"), float("inf")) + return parsed_version + + +class YicesSolver(SMTLIBSolver): + def __init__(self): + init = ["(set-logic QF_AUFBV)"] + command = f"{consts.yices_bin} --timeout={consts.timeout * 1000} --incremental" + super().__init__( + command=command, + init=init, + value_fmt=2, + debug=False, + support_minmax=False, + support_reset=False, + ) + + +class CVC4Solver(SMTLIBSolver): + def __init__(self): + init = ["(set-logic QF_AUFBV)", "(set-option :produce-models true)"] + command = f"{consts.cvc4_bin} --lang=smt2 --incremental" + super().__init__(command=command, value_fmt=10, init=init) + + +class SelectedSolver: + choice = None + + @classmethod + def instance(cls): + if consts.solver == consts.solver.auto: + if cls.choice is None: + if shutil.which(consts.yices_bin): + cls.choice = consts.solver.yices + elif shutil.which(consts.z3_bin): + cls.choice = consts.solver.z3 + elif shutil.which(consts.cvc4_bin): + cls.choice = consts.solver.cvc4 + else: + raise SolverException( + f"No Solver not found. Install one ({consts.yices_bin}, {consts.z3_bin}, {consts.cvc4_bin})." + ) + else: + cls.choice = consts.solver + + SelectedSolver = {"cvc4": CVC4Solver, "yices": YicesSolver, "z3": Z3Solver}[cls.choice.name] + return SelectedSolver.instance() diff --git a/manticore/core/state.py b/manticore/core/state.py index abb5060e5..93067d772 100644 --- a/manticore/core/state.py +++ b/manticore/core/state.py @@ -320,9 +320,9 @@ def concretize(self, symbolic, policy, maxcount=7): @property def _solver(self): - from .smtlib import Z3Solver + from .smtlib import SelectedSolver - return Z3Solver.instance() # solver + return SelectedSolver.instance() # solver def migrate_expression(self, expression): if not issymbolic(expression): diff --git a/manticore/core/workspace.py b/manticore/core/workspace.py index f77093e61..6041ba1ef 100644 --- a/manticore/core/workspace.py +++ b/manticore/core/workspace.py @@ -29,7 +29,7 @@ def __exit__(self, *excinfo): import threading from ..utils import config from ..utils.helpers import StateSerializer, PickleSerializer -from .smtlib.solver import Z3Solver +from .smtlib.solver import SelectedSolver from .state import StateBase from ..exceptions import ManticoreError @@ -658,5 +658,5 @@ def save_constraints(testcase, state: StateBase): def save_input_symbols(testcase, state: StateBase): with testcase.open_stream("input") as f: for symbol in state.input_symbols: - buf = Z3Solver.instance().get_value(state.constraints, symbol) + buf = SelectedSolver.instance().get_value(state.constraints, symbol) f.write(f"{symbol.name}: {buf!r}\n") diff --git a/manticore/ethereum/manticore.py b/manticore/ethereum/manticore.py index 82656f07f..32a0d78a5 100644 --- a/manticore/ethereum/manticore.py +++ b/manticore/ethereum/manticore.py @@ -25,7 +25,7 @@ Expression, issymbolic, simplify, - Z3Solver, + SelectedSolver, ) from ..core.state import TerminateState, AbandonState from .account import EVMContract, EVMAccount, ABI @@ -585,7 +585,7 @@ def solidity_create_contract( constructor_data = b"" # Balance could be symbolic, lets ask the solver # Option 1: balance can not be 0 and the function is marked as not payable - if not Z3Solver.instance().can_be_true(self.constraints, balance == 0): + if not SelectedSolver.instance().can_be_true(self.constraints, balance == 0): # balance always != 0 if not md.constructor_abi["payable"]: raise EthereumError( @@ -596,7 +596,7 @@ def solidity_create_contract( for state in self.ready_states: world = state.platform - if not Z3Solver.instance().can_be_true( + if not SelectedSolver.instance().can_be_true( self.constraints, Operators.UGE(world.get_balance(owner.address), balance), ): diff --git a/manticore/native/cpu/abstractcpu.py b/manticore/native/cpu/abstractcpu.py index 2a41e88dd..57489de5c 100644 --- a/manticore/native/cpu/abstractcpu.py +++ b/manticore/native/cpu/abstractcpu.py @@ -13,7 +13,7 @@ from ..memory import LazySMemory, Memory from ...core.smtlib import Operators, Constant, issymbolic from ...core.smtlib import visitors -from ...core.smtlib.solver import Z3Solver +from ...core.smtlib.solver import SelectedSolver from ...utils.emulate import ConcreteUnicornEmulator from ...utils.event import Eventful from ...utils.fallback_emulator import UnicornEmulator @@ -908,7 +908,7 @@ def decode_instruction(self, pc: int): c = bytes([vals[0]]) except visitors.ArraySelectSimplifier.ExpressionNotSimple: c = struct.pack( - "B", Z3Solver.instance().get_value(self.memory.constraints, c) + "B", SelectedSolver.instance().get_value(self.memory.constraints, c) ) elif isinstance(c, Constant): c = bytes([c.value]) diff --git a/manticore/native/manticore.py b/manticore/native/manticore.py index 5ec14e3b9..95827b706 100644 --- a/manticore/native/manticore.py +++ b/manticore/native/manticore.py @@ -12,7 +12,7 @@ from .state import State from ..core.manticore import ManticoreBase from ..core.smtlib import ConstraintSet -from ..core.smtlib.solver import Z3Solver, issymbolic +from ..core.smtlib.solver import SelectedSolver, issymbolic from ..exceptions import ManticoreError from ..utils import log, config @@ -190,7 +190,7 @@ def _assertions_callback(self, state, pc, instruction): # This will interpret the buffer specification written in INTEL ASM. # (It may dereference pointers) assertion = parse(program, state.cpu.read_int, state.cpu.read_register) - if not Z3Solver.instance().can_be_true(state.constraints, assertion): + if not SelectedSolver.instance().can_be_true(state.constraints, assertion): logger.info(str(state.cpu)) logger.info( "Assertion %x -> {%s} does not hold. Aborting state.", state.cpu.pc, program diff --git a/manticore/native/memory.py b/manticore/native/memory.py index 062291c03..6afea1a85 100644 --- a/manticore/native/memory.py +++ b/manticore/native/memory.py @@ -5,7 +5,7 @@ Operators, ConstraintSet, arithmetic_simplify, - Z3Solver, + SelectedSolver, TooManySolutions, BitVec, BitVecConstant, @@ -1194,7 +1194,7 @@ def read(self, address, size, force=False): solutions = self._try_get_solutions(address, size, "r", force=force) assert len(solutions) > 0 except TooManySolutions as e: - solver = Z3Solver.instance() + solver = SelectedSolver.instance() m, M = solver.minmax(self.constraints, address) logger.debug( f"Got TooManySolutions on a symbolic read. Range [{m:x}, {M:x}]. Not crashing!" @@ -1327,7 +1327,7 @@ def _try_get_solutions(self, address, size, access, max_solutions=0x1000, force= :rtype: list """ assert issymbolic(address) - solver = Z3Solver.instance() + solver = SelectedSolver.instance() solutions = solver.get_all_values( self.constraints, address, maxcnt=max_solutions, silent=True ) @@ -1437,7 +1437,7 @@ def _deref_can_succeed(self, mapping, address, size): if not issymbolic(address): return address >= mapping.start and address + size < mapping.end else: - solver = Z3Solver.instance() + solver = SelectedSolver.instance() constraint = Operators.AND(address >= mapping.start, address + size < mapping.end) return solver.can_be_true(self.constraints, constraint) @@ -1475,7 +1475,7 @@ def _map_deref_expr(self, map, address): return Operators.AND(Operators.UGE(address, map.start), Operators.ULT(address, map.end)) def _reachable_range(self, sym_address, size): - solver = Z3Solver.instance() + solver = SelectedSolver.instance() addr_min, addr_max = solver.minmax(self.constraints, sym_address) return addr_min, addr_max + size - 1 diff --git a/manticore/native/models.py b/manticore/native/models.py index 4cbfa3951..8930ddaff 100644 --- a/manticore/native/models.py +++ b/manticore/native/models.py @@ -4,7 +4,7 @@ from .cpu.abstractcpu import ConcretizeArgument from ..core.smtlib import issymbolic -from ..core.smtlib.solver import Z3Solver +from ..core.smtlib.solver import SelectedSolver from ..core.smtlib.operators import ITEBV, ZEXTEND VARIADIC_FUNC_ATTR = "_variadic" @@ -46,7 +46,7 @@ def _find_zero(cpu, constrs, ptr): byt = cpu.read_int(ptr + offset, 8) if issymbolic(byt): - if not Z3Solver.instance().can_be_true(constrs, byt != 0): + if not SelectedSolver.instance().can_be_true(constrs, byt != 0): break else: if byt == 0: diff --git a/manticore/native/state_merging.py b/manticore/native/state_merging.py index 51836c764..2ff9f2e64 100644 --- a/manticore/native/state_merging.py +++ b/manticore/native/state_merging.py @@ -1,4 +1,4 @@ -from ..core.smtlib import Z3Solver, ConstraintSet, Operators, issymbolic, BitVec +from ..core.smtlib import SelectedSolver, ConstraintSet, Operators, issymbolic, BitVec def compare_sockets(cs, socket1, socket2): @@ -7,7 +7,7 @@ def compare_sockets(cs, socket1, socket2): It uses `compare_buffers` for checking buffer attributes for equality. It calls itself for comparing peer Socket objects. Returns True if the Socket objects are equal, false otherwise. - :param cs: ConstraintSet to be used for checking Socket.buffer for semantic equality using `Z3Solver.instance().must_be_true()` + :param cs: ConstraintSet to be used for checking Socket.buffer for semantic equality using `SelectedSolver.instance().must_be_true()` :param socket1: one of two Socket objects to be compared for equality against socket2 :param socket2: one of two Socket objects to be compared for equality against socket1 :return: True, if the Socket objects are found to be equal, False otherwise @@ -23,8 +23,8 @@ def compare_sockets(cs, socket1, socket2): def compare_buffers(cs, buffer1, buffer2): """ - This method compares the two List objects for equality using the `Z3Solver.instance().must_be_true()` call. - :param cs: ConstraintSet to be used for checking buffer1 for semantic equality with buffer2 using `Z3Solver.instance().must_be_true()` + This method compares the two List objects for equality using the `SelectedSolver.instance().must_be_true()` call. + :param cs: ConstraintSet to be used for checking buffer1 for semantic equality with buffer2 using `SelectedSolver.instance().must_be_true()` :param buffer1: one of two List objects to be compared for equality against buffer2 :param buffer2: one of two List objects to be compared for equality against buffer1 :return: True, if the List objects are equal, False otherwise @@ -32,7 +32,7 @@ def compare_buffers(cs, buffer1, buffer2): if len(buffer1) != len(buffer2): return False for b1, b2 in zip(buffer1, buffer2): - if not Z3Solver.instance().must_be_true(cs, b1 == b2): + if not SelectedSolver.instance().must_be_true(cs, b1 == b2): return False return True @@ -62,7 +62,7 @@ def compare_byte_vals(mem1, mem2, addr, merged_constraint): :param mem1: first of two memory objects we want to use for comparison :param mem2: second of two memory objects we want to use for comparison :param addr: address at which bytes values are to be compared - :param merged_constraint: ConstraintSet to be used when using the call to `Z3Solver.instance().must_be_true()` + :param merged_constraint: ConstraintSet to be used when using the call to `SelectedSolver.instance().must_be_true()` :return: returns True if 1 byte values at address `addr` in `mem1` and `mem2` are semantically equal, False otherwise """ val1 = mem1.read(addr, 1) @@ -70,7 +70,7 @@ def compare_byte_vals(mem1, mem2, addr, merged_constraint): # since we only read a single byte value, these lists should only have one entry in them assert len(val1) == 1 and len(val2) == 1 cond_to_check = val1[0] == val2[0] - if not Z3Solver.instance().must_be_true(merged_constraint, cond_to_check): + if not SelectedSolver.instance().must_be_true(merged_constraint, cond_to_check): return False else: return True @@ -85,7 +85,7 @@ def compare_mem(mem1, mem2, merged_constraint): type SMemory. :param mem1: one of two memory objects to be compared :param mem2: second of two memory objects to be compared - :param merged_constraint: ConstraintSet object that is to be used with `Z3Solver.instance().must_be_true()` calls to check the + :param merged_constraint: ConstraintSet object that is to be used with `SelectedSolver.instance().must_be_true()` calls to check the memory objects for semantic equality :return: True, if the memory objects are equal, False otherwise """ @@ -180,7 +180,7 @@ def merge_cpu(cpu1, cpu2, state, exp1, merged_constraint): :param exp1: the expression that if satisfiable will cause the CPU registers to take corresponding values from `cpu1`, else they will take corresponding values from `cpu2` :param merged_constraint: ConstraintSet under which we would want inequality between CPU register values to be - satisfiable as checked using `Z3Solver.instance().must_be_true()` + satisfiable as checked using `SelectedSolver.instance().must_be_true()` :return: List of registers that were merged """ merged_regs = [] @@ -190,7 +190,7 @@ def merge_cpu(cpu1, cpu2, state, exp1, merged_constraint): if isinstance(val1, BitVec) and isinstance(val2, BitVec): assert val1.size == val2.size if issymbolic(val1) or issymbolic(val2) or val1 != val2: - if Z3Solver.instance().must_be_true(merged_constraint, val1 != val2): + if SelectedSolver.instance().must_be_true(merged_constraint, val1 != val2): merged_regs.append(reg) if cpu1.regfile.sizeof(reg) == 1: state.cpu.write_register(reg, Operators.ITE(exp1, val1, val2)) diff --git a/manticore/platforms/evm.py b/manticore/platforms/evm.py index 5fdec1a53..0b85987f4 100644 --- a/manticore/platforms/evm.py +++ b/manticore/platforms/evm.py @@ -9,7 +9,7 @@ from typing import List, Set, Tuple, Union from ..platforms.platform import * from ..core.smtlib import ( - Z3Solver, + SelectedSolver, BitVec, Array, ArrayProxy, @@ -1233,7 +1233,7 @@ def _check_jmpdest(self): if isinstance(should_check_jumpdest, Constant): should_check_jumpdest = should_check_jumpdest.value elif issymbolic(should_check_jumpdest): - should_check_jumpdest_solutions = Z3Solver.instance().get_all_values( + should_check_jumpdest_solutions = SelectedSolver.instance().get_all_values( self.constraints, should_check_jumpdest ) if len(should_check_jumpdest_solutions) != 1: @@ -1719,7 +1719,7 @@ def CALLDATACOPY(self, mem_offset, data_offset, size): if consts.oog == "complete": # gas reduced #?? cond = Operators.ULT(self.gas, self._checkpoint_data[1]) - if not Z3Solver.instance().can_be_true(self.constraints, cond): + if not SelectedSolver.instance().can_be_true(self.constraints, cond): raise NotEnoughGas() self.constraints.add(cond) @@ -1728,7 +1728,7 @@ def CALLDATACOPY(self, mem_offset, data_offset, size): max_size = size if issymbolic(max_size): - max_size = Z3Solver.instance().max(self.constraints, size) + max_size = SelectedSolver.instance().max(self.constraints, size) if calldata_overflow is not None: cap = len(self.data) + calldata_overflow @@ -1776,7 +1776,7 @@ def CODECOPY(self, mem_offset, code_offset, size): self._consume(copyfee) if issymbolic(size): - max_size = Z3Solver.instance().max(self.constraints, size) + max_size = SelectedSolver.instance().max(self.constraints, size) else: max_size = size @@ -2442,7 +2442,7 @@ def try_simplify_to_constant(self, data): concrete_data.append(simplified.value) else: # simplify by solving. probably means that we need to improve simplification - solutions = Z3Solver.instance().get_all_values( + solutions = SelectedSolver.instance().get_all_values( self.constraints, simplified, 2, silent=True ) if len(solutions) != 1: @@ -2467,7 +2467,7 @@ def symbolic_function(self, func, data): return result[0] except Exception as e: logger.info("Error! %r", e) - data_c = Z3Solver.instance().get_value(self.constraints, data) + data_c = SelectedSolver.instance().get_value(self.constraints, data) return int(sha3.keccak_256(data_c).hexdigest(), 16) @property @@ -3408,7 +3408,7 @@ def dump(self, stream, state, mevm, message): # temp_cs.add(storage.get(index) != 0) temp_cs.add(storage.is_known(index)) # Query the solver to get all storage indexes with used slots - all_used_indexes = Z3Solver.instance().get_all_values(temp_cs, index) + all_used_indexes = SelectedSolver.instance().get_all_values(temp_cs, index) if all_used_indexes: stream.write("Storage:\n") diff --git a/manticore/platforms/linux.py b/manticore/platforms/linux.py index c4f746d70..bc2e88f01 100644 --- a/manticore/platforms/linux.py +++ b/manticore/platforms/linux.py @@ -27,7 +27,7 @@ from .linux_syscall_stubs import SyscallStubs from ..core.state import TerminateState from ..core.smtlib import ConstraintSet, Operators, Expression, issymbolic, ArrayProxy -from ..core.smtlib.solver import Z3Solver +from ..core.smtlib.solver import SelectedSolver from ..exceptions import SolverError from ..native.cpu.abstractcpu import Cpu, Syscall, ConcretizeArgument, Interruption from ..native.cpu.cpufactory import CpuFactory @@ -2299,7 +2299,7 @@ def sys_writev(self, fd, iov, count): size = cpu.read_int(iov + i * sizeof_iovec + (sizeof_iovec // 2), ptrsize) if issymbolic(size): - size = Z3Solver.instance().get_value(self.constraints, size) + size = SelectedSolver.instance().get_value(self.constraints, size) data = [Operators.CHR(cpu.read_int(buf + i, 8)) for i in range(size)] data = self._transform_write_data(data) @@ -3247,7 +3247,7 @@ def _transform_write_data(self, data: MixedSymbolicBuffer) -> bytes: for c in data: if issymbolic(c): bytes_concretized += 1 - c = bytes([Z3Solver.instance().get_value(self.constraints, c)]) + c = bytes([SelectedSolver.instance().get_value(self.constraints, c)]) concrete_data += cast(bytes, c) if bytes_concretized > 0: @@ -3259,7 +3259,7 @@ def _transform_write_data(self, data: MixedSymbolicBuffer) -> bytes: def sys_exit_group(self, error_code): if issymbolic(error_code): - error_code = Z3Solver.instance().get_value(self.constraints, error_code) + error_code = SelectedSolver.instance().get_value(self.constraints, error_code) return self._exit( f"Program finished with exit status: {ctypes.c_int32(error_code).value} (*)" ) @@ -3455,7 +3455,7 @@ def make_chr(c): try: for c in data: if issymbolic(c): - c = Z3Solver.instance().get_value(self.constraints, c) + c = SelectedSolver.instance().get_value(self.constraints, c) fd.write(make_chr(c)) except SolverError: fd.write("{SolverError}") diff --git a/manticore/utils/config.py b/manticore/utils/config.py index 5d3986488..bd43bd80d 100644 --- a/manticore/utils/config.py +++ b/manticore/utils/config.py @@ -27,6 +27,17 @@ class ConfigError(Exception): pass +class ConfigEnum(Enum): + """Used as configuration constant for choosing flavors""" + + def title(self): + return self._name_.title() + + @classmethod + def from_string(cls, name): + return cls.__members__[name] + + class _Var: def __init__(self, name: str = "", default=None, description: str = None, defined: bool = True): self.name = name diff --git a/manticore/utils/emulate.py b/manticore/utils/emulate.py index ebaa95656..47a294cf8 100644 --- a/manticore/utils/emulate.py +++ b/manticore/utils/emulate.py @@ -10,7 +10,7 @@ from unicorn.arm_const import * from unicorn.x86_const import * -from ..core.smtlib import Operators, Z3Solver, issymbolic +from ..core.smtlib import Operators, SelectedSolver, issymbolic from ..native.memory import MemoryException logger = logging.getLogger(__name__) @@ -351,7 +351,9 @@ def write_back_memory(self, where, expr, size): concrete_data = [] for c in data: if issymbolic(c): - c = chr(Z3Solver.instance().get_value(self._cpu.memory.constraints, c)) + c = chr( + SelectedSolver.instance().get_value(self._cpu.memory.constraints, c) + ) concrete_data.append(c) data = concrete_data else: diff --git a/manticore/wasm/manticore.py b/manticore/wasm/manticore.py index 5c3b7701e..8826c8e4c 100644 --- a/manticore/wasm/manticore.py +++ b/manticore/wasm/manticore.py @@ -5,7 +5,7 @@ from .state import State from ..core.manticore import ManticoreBase -from ..core.smtlib import ConstraintSet, issymbolic, Z3Solver +from ..core.smtlib import ConstraintSet, issymbolic, SelectedSolver from .types import I32, I64, F32, F64 from .structure import FuncInst @@ -161,7 +161,9 @@ def collect_returns(self, n=1): inner.append( list( I32(a) # TODO - eventually we'll need to support floats as well. - for a in Z3Solver.instance().get_all_values(state.constraints, ret) + for a in SelectedSolver.instance().get_all_values( + state.constraints, ret + ) ) ) elif ret.size == 64: @@ -170,7 +172,9 @@ def collect_returns(self, n=1): I64( a ) # TODO - that'll probably require us to subclass bitvecs into IxxBV and FxxBV - for a in Z3Solver.instance().get_all_values(state.constraints, ret) + for a in SelectedSolver.instance().get_all_values( + state.constraints, ret + ) ) ) else: diff --git a/manticore/wasm/structure.py b/manticore/wasm/structure.py index 47c3515c2..667b052f2 100644 --- a/manticore/wasm/structure.py +++ b/manticore/wasm/structure.py @@ -65,9 +65,8 @@ SEC_UNK, ) -from ..core.smtlib.solver import Z3Solver +from ..core.smtlib.solver import SelectedSolver -solver = Z3Solver.instance() logger = logging.getLogger(__name__) # logger.setLevel(logging.DEBUG) @@ -732,6 +731,7 @@ def __setstate__(self, state): def _eval_maybe_symbolic(constraints, expression) -> bool: if issymbolic(expression): + solver = SelectedSolver.instance() return solver.must_be_true(constraints, expression) return True if expression else False diff --git a/tests/other/test_smtlibv2.py b/tests/other/test_smtlibv2.py index 2a93d8648..501d03ee8 100644 --- a/tests/other/test_smtlibv2.py +++ b/tests/other/test_smtlibv2.py @@ -1,4 +1,5 @@ import unittest +from unittest.mock import patch, mock_open from manticore.core.smtlib import ( ConstraintSet, @@ -12,7 +13,7 @@ constant_folder, replace, ) -from manticore.core.smtlib.solver import Z3Solver +from manticore.core.smtlib.solver import Z3Solver, YicesSolver, CVC4Solver from manticore.core.smtlib.expression import * from manticore.utils.helpers import pickle_dumps @@ -21,6 +22,43 @@ # level = logging.DEBUG) +""" +class Z3Specific(unittest.TestCase): + _multiprocess_can_split_ = True + + def setUp(self): + self.solver = Z3Solver.instance() + + + @patch('subprocess.check_output', mock_open()) + def test_check_solver_min(self, mock_check_output): + mock_check_output.return_value = ("output", "Error") + #mock_check_output.return_value='(:version "4.4.1")' + #mock_function = create_autospec(function, return_value='(:version "4.4.1")') + #with patch.object(subprocess, 'check_output' , return_value='(:version "4.4.1")'): + #test_patch.return_value = '(:version "4.4.1")' + print (self.solver._solver_version()) + self.assertTrue(self.solver._solver_version() == Version(major=4, minor=4, patch=1)) + + def test_check_solver_newer(self): + self.solver._received_version = '(:version "4.5.0")' + self.assertTrue(self.solver._solver_version() > Version(major=4, minor=4, patch=1)) + + def test_check_solver_long_format(self): + self.solver._received_version = '(:version "4.8.6 - build hashcode 78ed71b8de7d")' + self.assertTrue(self.solver._solver_version() == Version(major=4, minor=8, patch=6)) + + def test_check_solver_undefined(self): + self.solver._received_version = '(:version "78ed71b8de7d")' + self.assertTrue( + + self.solver._solver_version() + == Version(major=float("inf"), minor=float("inf"), patch=float("inf")) + ) + self.assertTrue(self.solver._solver_version() > Version(major=4, minor=4, patch=1)) +""" + + class ExpressionTest(unittest.TestCase): _multiprocess_can_split_ = True @@ -966,26 +1004,6 @@ def test_NOT(self): self.assertTrue(solver.must_be_true(cs, Operators.NOT(False))) self.assertTrue(solver.must_be_true(cs, Operators.NOT(a == b))) - def test_check_solver_min(self): - self.solver._received_version = '(:version "4.4.1")' - self.assertTrue(self.solver._solver_version() == Version(major=4, minor=4, patch=1)) - - def test_check_solver_newer(self): - self.solver._received_version = '(:version "4.5.0")' - self.assertTrue(self.solver._solver_version() > Version(major=4, minor=4, patch=1)) - - def test_check_solver_long_format(self): - self.solver._received_version = '(:version "4.8.6 - build hashcode 78ed71b8de7d")' - self.assertTrue(self.solver._solver_version() == Version(major=4, minor=8, patch=6)) - - def test_check_solver_undefined(self): - self.solver._received_version = '(:version "78ed71b8de7d")' - self.assertTrue( - self.solver._solver_version() - == Version(major=float("inf"), minor=float("inf"), patch=float("inf")) - ) - self.assertTrue(self.solver._solver_version() > Version(major=4, minor=4, patch=1)) - def test_API(self): """ As we've split up the Constant, Variable, and Operation classes to avoid using multiple inheritance, @@ -1009,5 +1027,15 @@ def test_API(self): self.assertTrue(hasattr(cls, attr), f"{cls.__name__} is missing attribute {attr}") +class ExpressionTestYices(ExpressionTest): + def setUp(self): + self.solver = YicesSolver.instance() + + +class ExpressionTestCVC4(ExpressionTest): + def setUp(self): + self.solver = CVC4Solver.instance() + + if __name__ == "__main__": unittest.main() From bdbd0391c876450ad0a4353e9c79f695e3f5c5c5 Mon Sep 17 00:00:00 2001 From: sschriner <60201678+sschriner@users.noreply.github.com> Date: Tue, 9 Jun 2020 17:12:19 -0400 Subject: [PATCH 10/28] Symbolic model for strcpy (#1681) * Working copy for strcpy - without symbolic input * Corrected null term error * Needs to be tested but general algorithm idea for handling symbolic input * Updated according to feedback * Beginning of strcpy tests * Revising strcpy algorithm - realised it was flawed * This should be a more correct way of handling symbolic bytes. Needs testing * Get rid of redundant code * Fixed another typo * Update manticore/native/models.py Co-Authored-By: Eric Kilmer * Clarified and updated comments * Fixed some errors in model while working on tests * Progress on tests * Found typo in models * Removed unnecassary whitespace * Added some helper functions for tests and to clean things up * Added comments for helper functions * WIP: current state of strcpy tests * Updated type hints from Expression to BitVec * Fixed linter complaints * Updated strcpy return type to make linter happy * Added some helper properties to expression BitVecITE * Overwrote equal op in ArraySelect * Fixed formatting in expression * Almost done just needs some cleaning * Attempt at overriding __eq__ again * Cleaned up tests some still have unresolved __eq__ issues * Removed stuff from expression and updated test_models.py * Removed stuff from expression and updated test_models.py * Basicly done probably needs some more comments for clarity * Cleaned up the tests a little * Corrected linter error and added more comments to strcpy model functions * Remove duplicated word in comment Co-authored-by: Eric Kilmer * Update manticore/native/models.py Co-authored-by: Brad Larsen * Update manticore/native/models.py Co-authored-by: Brad Larsen * Update tests/native/test_models.py Co-authored-by: Brad Larsen * Updates according to feedback * Swapped can_be_true and must be true * Updates for feedback * Forgot to lint * Fixed some typos * Largely simplified ITE being built * Forgot to lint * This is messy but seems to be concretizing to the correct states * Very very messy state of the code before attempting to concretize on every possible NULL * Cleaned up model with forking on every possible NULL * Removed trailing whitespace for CodeClimate * Added state.context for offset value back * New symbolic test with regex for expected output * New symbolic test with regex for expected output * Updated for mypy * Updated comments in tests * Updated cant_be_null to cannot_be_null * Corrected docstring location for _test_strcpy * Add break for efficiency * Added compiler information and source file * Updated regex to use raw strings Co-authored-by: Eric Kilmer Co-authored-by: Brad Larsen --- manticore/core/smtlib/expression.py | 12 ++ manticore/native/models.py | 110 ++++++++++++++-- tests/native/binaries/sym_strcpy_test | Bin 0 -> 847536 bytes tests/native/binaries/sym_strcpy_test.c | 22 ++++ tests/native/test_models.py | 159 +++++++++++++++++++++++- 5 files changed, 292 insertions(+), 11 deletions(-) create mode 100755 tests/native/binaries/sym_strcpy_test create mode 100644 tests/native/binaries/sym_strcpy_test.c diff --git a/manticore/core/smtlib/expression.py b/manticore/core/smtlib/expression.py index 7e964ad8a..d0634ab53 100644 --- a/manticore/core/smtlib/expression.py +++ b/manticore/core/smtlib/expression.py @@ -1289,6 +1289,18 @@ def __init__( assert false_value.size == size super().__init__(size, condition, true_value, false_value, *args, **kwargs) + @property + def condition(self): + return self.operands[0] + + @property + def true_value(self): + return self.operands[1] + + @property + def false_value(self): + return self.operands[2] + Constant = (BitVecConstant, BoolConstant) Variable = (BitVecVariable, BoolVariable, ArrayVariable) diff --git a/manticore/native/models.py b/manticore/native/models.py index 8930ddaff..699a86be0 100644 --- a/manticore/native/models.py +++ b/manticore/native/models.py @@ -2,10 +2,13 @@ Models here are intended to be passed to :meth:`~manticore.native.state.State.invoke_model`, not invoked directly. """ -from .cpu.abstractcpu import ConcretizeArgument -from ..core.smtlib import issymbolic +from .cpu.abstractcpu import Cpu, ConcretizeArgument +from .state import State +from ..core.smtlib import issymbolic, BitVec from ..core.smtlib.solver import SelectedSolver from ..core.smtlib.operators import ITEBV, ZEXTEND +from ..core.state import Concretize +from typing import Union VARIADIC_FUNC_ATTR = "_variadic" @@ -57,7 +60,7 @@ def _find_zero(cpu, constrs, ptr): return offset -def strcmp(state, s1, s2): +def strcmp(state: State, s1: Union[int, BitVec], s2: Union[int, BitVec]): """ strcmp symbolic model. @@ -76,8 +79,8 @@ def strcmp(state, s1, s2): the two :param State state: Current program state - :param int s1: Address of string 1 - :param int s2: Address of string 2 + :param s1: Address of string 1 + :param s2: Address of string 2 :return: Symbolic strcmp result :rtype: Expression or int """ @@ -113,14 +116,14 @@ def strcmp(state, s1, s2): return ret -def strlen(state, s): +def strlen(state: State, s: Union[int, BitVec]) -> Union[int, BitVec]: """ strlen symbolic model. Algorithm: Walks from end of string not including NULL building ITE tree when current byte is symbolic. :param State state: current program state - :param int s: Address of string + :param s: Address of string :return: Symbolic strlen result :rtype: Expression or int """ @@ -140,3 +143,96 @@ def strlen(state, s): ret = ITEBV(cpu.address_bit_size, byt == 0, offset, ret) return ret + + +def is_definitely_NULL(byte, constrs) -> bool: + """ + Checks if a given byte read from memory is NULL. + This supports both concrete & symbolic byte values. + + :param byte: byte read from memory to be examined + :param constrs: state constraints + :return: whether a given byte is NULL or constrained to NULL + """ + if issymbolic(byte): + return SelectedSolver.instance().must_be_true(constrs, byte == 0) + else: + return byte == 0 + + +def cannot_be_NULL(byte, constrs) -> bool: + """ + Checks if a given byte read from memory is not NULL or cannot be NULL + + :param byte: byte read from memory to be examined + :param constrs: state constraints + :return: whether a given byte is not NULL or cannot be NULL + """ + if issymbolic(byte): + return SelectedSolver.instance().must_be_true(constrs, byte != 0) + else: + return byte != 0 + + +def can_be_NULL(byte, constrs) -> bool: + """ + Checks if a given byte read from memory can be NULL + + :param byte: byte read from memory to be examined + :param constrs: state constraints + :return: whether a given byte is NULL or can be NULL + """ + if issymbolic(byte): + return SelectedSolver.instance().can_be_true(constrs, byte == 0) + else: + return byte == 0 + + +def strcpy(state: State, dst: Union[int, BitVec], src: Union[int, BitVec]) -> Union[int, BitVec]: + """ + strcpy symbolic model + + Algorithm: Copy every byte from src to dst until finding a byte that is NULL or is + constrained to only the NULL value. Every time a byte is fouund that can be NULL but + is not definetly NULL concretize and fork states. + + :param state: current program state + :param dst: destination string address + :param src: source string address + :return: pointer to the dst + """ + if issymbolic(src): + raise ConcretizeArgument(state.cpu, 1) + + if issymbolic(dst): + raise ConcretizeArgument(state.cpu, 0) + + cpu = state.cpu + constrs = state.constraints + ret = dst + + # Initialize offset based on whether state has been forked in strcpy + if "strcpy" not in state.context: + offset = 0 + else: + offset = state.context["strcpy"] + + # Copy until a src_byte is symbolic and constrained to '\000', or is concrete and '\000' + src_val = cpu.read_int(src + offset, 8) + while not is_definitely_NULL(src_val, constrs): + cpu.write_int(dst + offset, src_val, 8) + + # If a byte can be NULL set the src_val for concretize and fork states + if can_be_NULL(src_val, constrs): + state.context["strcpy"] = offset + raise Concretize("Forking on NULL strcpy", expression=(src_val == 0), policy="ALL") + offset += 1 + + src_val = cpu.read_int(src + offset, 8) + + # Write concrete null for end of string in current state + cpu.write_int(dst + offset, 0, 8) + + if "strcpy" in state.context: + del state.context["strcpy"] + return ret diff --git a/tests/native/binaries/sym_strcpy_test b/tests/native/binaries/sym_strcpy_test new file mode 100755 index 0000000000000000000000000000000000000000..cc52091514fcd380d157c6508886748cd1883f65 GIT binary patch literal 847536 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π@V}^iD&FrcBk^;#v9Pbb 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 z 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%0A}s2_FYuL_yhqR-!iIzJ0-etxlmr&(jjc&)Cz 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

ISt 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�)81(-(buOx(`^LtxsPPw*edqv)?J375Wd#m*;lK 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

)l| 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 literal 0 HcmV?d00001 diff --git a/tests/native/binaries/sym_strcpy_test.c b/tests/native/binaries/sym_strcpy_test.c new file mode 100644 index 000000000..698c5de9b --- /dev/null +++ b/tests/native/binaries/sym_strcpy_test.c @@ -0,0 +1,22 @@ +#include +#include +#include +#include +#define LEN 5 + +int main() { + char * A = "src or dst is A"; + char * NA = "src or dst is not A"; + char src[LEN]; + char dst[sizeof(src)]; + read(0, src, sizeof(src)); + + strcpy(dst, src); + if (dst[1] == 'A' || src[1] == 'A'){ + printf(A); + } + if (dst[1] != 'A' && src[1] != 'A'){ + printf(NA); + } + return 0; +} diff --git a/tests/native/test_models.py b/tests/native/test_models.py index eaaed3790..f33b19f18 100644 --- a/tests/native/test_models.py +++ b/tests/native/test_models.py @@ -1,11 +1,30 @@ import unittest import os - -from manticore.core.smtlib import ConstraintSet, Z3Solver +import random +import tempfile +from glob import glob +import re + +from manticore.core.smtlib import ( + ConstraintSet, + Operators, + Z3Solver, + issymbolic, + ArraySelect, + BitVecITE, +) from manticore.native.state import State from manticore.platforms import linux - -from manticore.native.models import variadic, isvariadic, strcmp, strlen +from manticore.native import Manticore +from manticore.native.models import ( + variadic, + isvariadic, + strcmp, + strlen, + strcpy, + is_definitely_NULL, + cannot_be_NULL, +) class ModelMiscTest(unittest.TestCase): @@ -43,6 +62,16 @@ def _push_string(self, s): cpu.write_bytes(cpu.RSP, s) return cpu.RSP + def _push_string_space(self, l): + cpu = self.state.cpu + cpu.RSP -= l + return cpu.RSP + + def _pop_string_space(self, l): + cpu = self.state.cpu + cpu.RSP += l + return cpu.RSP + def assertItemsEqual(self, a, b): # Required for Python3 compatibility self.assertEqual(sorted(a), sorted(b)) @@ -198,3 +227,125 @@ def test_symbolic_mixed(self): self.state.constrain(sy[3] != 0) ret = strlen(self.state, s) self.assertTrue(self.state.must_be_true(ret == 4)) + + +class StrcpyTest(ModelTest): + def _assert_concrete(self, s, d): + # Checks all characters are copied until the 1st that could be NULL + cpu = self.state.cpu + src = cpu.read_int(s, 8) + dst = cpu.read_int(d, 8) + offset = 0 + while cannot_be_NULL(src, self.state.constraints): + self.assertTrue(not issymbolic(dst)) + self.assertEqual(src, dst) + offset += 1 + src = cpu.read_int(s + offset, 8) + dst = cpu.read_int(d + offset, 8) + + # Assert final NULL byte + self.assertTrue(is_definitely_NULL(src, self.state.constraints)) + self.assertEqual(0, dst) + return offset + + def _test_strcpy(self, string, dst_len=None): + """ + This method creates memory for a given src (with no possible NULL bytes but and a + final NULL byte) and dst string pointers, asserts that everything is copied from src + to dst until the NULL byte, and asserts the memory address returned by strcpy is + equal to the given dst address. + """ + # Create src and dsty strings + if dst_len is None: + dst_len = len(string) + cpu = self.state.cpu + s = self._push_string(string) + d = self._push_string_space(dst_len) + dst_vals = [None] * dst_len + for i in range(dst_len): + # Set each dst byte to a random char to simplify equal comparisons + c = random.randrange(1, 255) + cpu.write_int(d + i, c, 8) + dst_vals[i] = c + + ret = strcpy(self.state, d, s) + + # addresses should match + self.assertEqual(ret, d) + # assert everything is copied up to the 1st possible 0 is copied + offset = self._assert_concrete(s, d) + + # Delete stack space created + self._pop_string_space(dst_len + len(string)) + + def test_concrete(self): + self._test_strcpy("abc\0") + self._test_strcpy("a\0", dst_len=10) + self._test_strcpy("abcdefghijklm\0") + self._test_strcpy("a\0", dst_len=5) + + def test_concrete_empty(self): + self._test_strcpy("\0") + self._test_strcpy("\0", dst_len=10) + + def test_symbolic(self): + # This binary is compiled using gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 + # with flags: -g -static -fno-builtin + BIN_PATH = os.path.join(os.path.dirname(__file__), "binaries", "sym_strcpy_test") + tmp_dir = tempfile.TemporaryDirectory(prefix="mcore_test_sym_") + m = Manticore(BIN_PATH, stdin_size=10, workspace_url=str(tmp_dir.name)) + + addr_of_strcpy = 0x400418 + + @m.hook(addr_of_strcpy) + def strlen_model(state): + state.invoke_model(strcpy) + + m.run() + m.finalize() + + # Approximate regexes for expected testcase output + # Example Match above each regex + # Manticore varies the hex output slightly per run + expected = [ + # STDIN: b'\x00AAAAAAAAA' + r"STDIN: b\'\\x00A.{8,32}\'", + # STDIN: b'\xffA\x00\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))[0-9a-f]{2}))A\\x00(\\x([0-9a-f]{2})){7}\'", + # STDIN: b'\xffA\xff\x00\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))[0-9a-f]{2}))A(\\x((?!(00))[0-9a-f]{2}))\\x00(\\x([0-9a-f]{2})){6}\'", + # STDIN: b'\xffA\xff\xff\x00\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))[0-9a-f]{2}))A(\\x((?!(00))[0-9a-f]{2})){2}\\x00(\\x([0-9a-f]{2})){5}\'", + # STDIN: b'\x00\xbe\xbe\xbe\xbe\xbe\xbe\xbe\xbe\xbe' + r"STDIN: b\'\\x00(\\x([0-9a-f]{2})){9}\'", + # STDIN: b'\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){1}\\x00(\\x([0-9a-f]{2})){8}\'", + # STDIN: b'\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){2}\\x00(\\x([0-9a-f]{2})){7}\'", + # STDIN: b'\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){3}\\x00(\\x([0-9a-f]{2})){6}\'", + # STDIN: b'\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){4}\\x00(\\x([0-9a-f]{2})){5}\'", + # STDIN: b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){10}\'", + ] + + inputs = f"{str(m.workspace)}/test_*.input" + + # Make a list of the generated input states + stdins = [] + for inpt in glob(inputs): + with open(inpt) as f: + stdins.append(f.read()) + + # Check the number of input states matches the number of regexes + self.assertEqual(len(stdins), len(expected)) + + # Assert that every regex has a matching input + for e in expected: + match = False + for s in stdins: + if re.fullmatch(e, s) == None: + match = True + break + self.assertTrue(match) From 099dc47b69b089fc550d47047735f6ff4fe77cc9 Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 16 Jun 2020 21:59:32 -0300 Subject: [PATCH 11/28] Fix constant folding & constraint set slicing (#1706) * Add ONE failing test * Fix test * Try fix get-related * Move regression to other * blkn * blkn * Move get related * CC * fix concolic * lint * DivByZero default to zero * blkn * Update manticore/core/smtlib/solver.py Co-authored-by: Eric Kilmer * Update manticore/core/smtlib/constraints.py Co-authored-by: Eric Kilmer * Update manticore/core/smtlib/constraints.py Co-authored-by: Eric Kilmer * remove odd string * lint * mypy lint * Update manticore/core/smtlib/visitors.py Co-authored-by: Eric Kilmer * lint * Add Docs * Replace modulo with masks * Blacken * blkn * fix mypy * fix mypy * Add tests for signed LT behavior * New test * Fix constant folding * lint * lint * lint * Unittesting power * Permisive read_buffer * Preserve precision in constant folding * Strip left-in print debugging * fix wasm * Fix * REmove get_related from the default path and fix arm test * blkn * fix related to tests * blkn * Fix bug in test and disable debug messages in Solver * smtlib config to disable multiple check-sat in newer z3 * Disable log test and fix merging poc vs variable migration * blkn * Avoid exception in some callbacks * can_raise at did_will * slightly better z3 onfiguration * lint Co-authored-by: Eric Kilmer Co-authored-by: Eric Hennenfent --- examples/script/concolic.py | 13 ++- manticore/core/manticore.py | 6 +- manticore/core/smtlib/constraints.py | 117 +++++++++++++++------------ manticore/core/smtlib/expression.py | 46 ++++++----- manticore/core/smtlib/solver.py | 95 +++++++++++----------- manticore/core/smtlib/visitors.py | 83 +++++++++++++++---- manticore/native/state_merging.py | 18 +++-- manticore/platforms/evm.py | 2 + manticore/utils/event.py | 20 +++-- manticore/wasm/executor.py | 37 ++++++--- tests/native/test_armv7cpu.py | 6 +- tests/native/test_linux.py | 2 +- tests/other/data/ErrRelated.pkl.gz | Bin 0 -> 17638 bytes tests/other/test_smtlibv2.py | 106 +++++++++++++++++++++++- 14 files changed, 383 insertions(+), 168 deletions(-) create mode 100644 tests/other/data/ErrRelated.pkl.gz diff --git a/examples/script/concolic.py b/examples/script/concolic.py index ab75e682a..ce3a90292 100755 --- a/examples/script/concolic.py +++ b/examples/script/concolic.py @@ -22,6 +22,8 @@ from manticore.core.plugin import ExtendedTracer, Follower, Plugin from manticore.core.smtlib.constraints import ConstraintSet from manticore.core.smtlib.solver import Z3Solver +from manticore.core.smtlib.visitors import GetDeclarations + from manticore.utils import config import copy @@ -136,8 +138,17 @@ def perm(lst, func): def constraints_to_constraintset(constupl): + # originally those constraints belonged to a different ConstraintSet + # This is a hack x = ConstraintSet() - x._constraints = list(constupl) + + declarations = GetDeclarations() + for a in constupl: + declarations.visit(a) + x.add(a) + for d in declarations.result: + x._declare(d) + return x diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index c2e0b47a8..92abd8c06 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -525,7 +525,7 @@ def verbosity(level): set_verbosity(level) # State storage - @Eventful.will_did("save_state") + @Eventful.will_did("save_state", can_raise=False) def _save(self, state, state_id=None): """ Store or update a state in secondary storage under state_id. Use a fresh id is None is provided. @@ -538,7 +538,7 @@ def _save(self, state, state_id=None): state._id = self._workspace.save_state(state, state_id=state_id) return state.id - @Eventful.will_did("load_state") + @Eventful.will_did("load_state", can_raise=False) def _load(self, state_id): """ Load the state from the secondary storage @@ -557,7 +557,7 @@ def _load(self, state_id): self.stcache[state_id] = state return state - @Eventful.will_did("remove_state") + @Eventful.will_did("remove_state", can_raise=False) def _remove(self, state_id): """ Remove a state from secondary storage diff --git a/manticore/core/smtlib/constraints.py b/manticore/core/smtlib/constraints.py index 711e5e91a..b35519aee 100644 --- a/manticore/core/smtlib/constraints.py +++ b/manticore/core/smtlib/constraints.py @@ -1,9 +1,11 @@ import itertools import sys - +import copy +from typing import Optional from ...utils.helpers import PickleSerializer from ...exceptions import SmtlibError from .expression import ( + Expression, BitVecVariable, BoolVariable, ArrayVariable, @@ -16,19 +18,19 @@ Variable, Constant, ) -from .visitors import GetDeclarations, TranslatorSmtlib, get_variables, simplify, replace +from .visitors import ( + GetDeclarations, + TranslatorSmtlib, + get_variables, + simplify, + replace, + pretty_print, +) from ...utils import config import logging logger = logging.getLogger(__name__) -consts = config.get_group("smt") -consts.add( - "related_constraints", - default=False, - description="Try slicing the current path constraint to contain only related items", -) - class ConstraintException(SmtlibError): """ @@ -115,7 +117,7 @@ def _get_sid(self) -> int: self._sid += 1 return self._sid - def __get_related(self, related_to=None): + def related_to(self, *related_to) -> "ConstraintSet": # sam.moelius: There is a flaw in how __get_related works: when called on certain # unsatisfiable sets, it can return a satisfiable one. The flaw arises when: # * self consists of a single constraint C @@ -127,49 +129,59 @@ def __get_related(self, related_to=None): # set. Thus, __get_related was called on an unsatisfiable set, {C}, but it returned a # satisfiable one, {}. # In light of the above, the core __get_related logic is currently disabled. - # if related_to is not None: - # feliam: This assumes the previous constraints are already SAT (normal SE forking) - if consts.related_constraints and related_to is not None: - number_of_constraints = len(self.constraints) - remaining_constraints = set(self.constraints) - related_variables = get_variables(related_to) - related_constraints = set() - - added = True - while added: - added = False - logger.debug("Related variables %r", [x.name for x in related_variables]) - for constraint in list(remaining_constraints): - if isinstance(constraint, BoolConstant): - if constraint.value: - continue - else: - related_constraints = {constraint} - break - - variables = get_variables(constraint) - if related_variables & variables or not (variables): - remaining_constraints.remove(constraint) - related_constraints.add(constraint) - related_variables |= variables - added = True - - logger.debug( - "Reduced %d constraints!!", number_of_constraints - len(related_constraints) - ) - else: - related_variables = set() - for constraint in self.constraints: - related_variables |= get_variables(constraint) - related_constraints = set(self.constraints) - return related_variables, related_constraints - - def to_string(self, related_to=None, replace_constants=False): - related_variables, related_constraints = self.__get_related(related_to) + """ + Slices this ConstraintSet keeping only the related constraints. + Two constraints are independient if they can be expressed full using a + disjoint set of variables. + Todo: Research. constraints refering differen not overlapping parts of the same array + should be considered independient. + :param related_to: An expression + :return: + """ + + if not related_to: + return copy.copy(self) + number_of_constraints = len(self.constraints) + remaining_constraints = set(self.constraints) + related_variables = set() + for expression in related_to: + related_variables |= get_variables(expression) + related_constraints = set() + + added = True + while added: + added = False + logger.debug("Related variables %r", [x.name for x in related_variables]) + for constraint in list(remaining_constraints): + if isinstance(constraint, BoolConstant): + if constraint.value: + continue + else: + related_constraints = {constraint} + break + + variables = get_variables(constraint) + if related_variables & variables or not (variables): + remaining_constraints.remove(constraint) + related_constraints.add(constraint) + related_variables |= variables + added = True + + logger.debug("Reduced %d constraints!!", number_of_constraints - len(related_constraints)) + # related_variables, related_constraints + cs = ConstraintSet() + for var in related_variables: + cs._declare(var) + for constraint in related_constraints: + cs.add(constraint) + return cs + + def to_string(self, replace_constants: bool = False) -> str: + variables, constraints = self.get_declared_variables(), self.constraints if replace_constants: constant_bindings = {} - for expression in related_constraints: + for expression in constraints: if ( isinstance(expression, BoolEqual) and isinstance(expression.operands[0], Variable) @@ -179,7 +191,7 @@ def to_string(self, related_to=None, replace_constants=False): tmp = set() result = "" - for var in related_variables: + for var in variables: # FIXME # band aid hack around the fact that we are double declaring stuff :( :( if var.declaration in tmp: @@ -187,8 +199,9 @@ def to_string(self, related_to=None, replace_constants=False): continue tmp.add(var.declaration) result += var.declaration + "\n" + translator = TranslatorSmtlib(use_bindings=True) - for constraint in related_constraints: + for constraint in constraints: if replace_constants: constraint = simplify(replace(constraint, constant_bindings)) # if no variables then it is a constant diff --git a/manticore/core/smtlib/expression.py b/manticore/core/smtlib/expression.py index d0634ab53..39838f015 100644 --- a/manticore/core/smtlib/expression.py +++ b/manticore/core/smtlib/expression.py @@ -504,6 +504,13 @@ def __hash__(self): def value(self): return self._value + @property + def signed_value(self): + if self._value & self.signmask: + return self._value - (1 << self.size) + else: + return self._value + class BitVecOperation(BitVec): __slots__ = ["_operands"] @@ -960,7 +967,7 @@ def value(self): return self.operands[2] -class ArraySlice(Array): +class ArraySlice(ArrayOperation): def __init__( self, array: Union["Array", "ArrayProxy"], offset: int, size: int, *args, **kwargs ): @@ -968,23 +975,22 @@ def __init__( raise ValueError("Array expected") if isinstance(array, ArrayProxy): array = array._array - super().__init__(array.index_bits, array.index_max, array.value_bits, *args, **kwargs) + super().__init__(array, **kwargs) - self._array = array self._slice_offset = offset self._slice_size = size @property - def underlying_variable(self): - return self._array.underlying_variable + def array(self): + return self.operands[0] @property - def operands(self): - return self._array.operands + def underlying_variable(self): + return self.array.underlying_variable @property def index_bits(self): - return self._array.index_bits + return self.array.index_bits @property def index_max(self): @@ -992,18 +998,14 @@ def index_max(self): @property def value_bits(self): - return self._array.value_bits - - @property - def taint(self): - return self._array.taint + return self.array.value_bits def select(self, index): - return self._array.select(index + self._slice_offset) + return self.array.select(index + self._slice_offset) def store(self, index, value): return ArraySlice( - self._array.store(index + self._slice_offset, value), + self.array.store(index + self._slice_offset, value), self._slice_offset, self._slice_size, ) @@ -1048,7 +1050,7 @@ def name(self): @property def operands(self): - return self._array.operands + return (self._array,) @property def index_bits(self): @@ -1145,13 +1147,13 @@ def written(self): # take out Proxy sleve array = self._array offset = 0 - while isinstance(array, ArraySlice): - # if it is a proxy over a slice take out the slice too - offset += array._slice_offset - array = array._array while not isinstance(array, ArrayVariable): - # The index written to underlaying Array are displaced when sliced - written.add(array.index - offset) + if isinstance(array, ArraySlice): + # if it is a proxy over a slice take out the slice too + offset += array._slice_offset + else: + # The index written to underlaying Array are displaced when sliced + written.add(array.index - offset) array = array.array assert isinstance(array, ArrayVariable) self._written = written diff --git a/manticore/core/smtlib/solver.py b/manticore/core/smtlib/solver.py index 365b83a0e..9d512c61a 100644 --- a/manticore/core/smtlib/solver.py +++ b/manticore/core/smtlib/solver.py @@ -205,6 +205,8 @@ def stop(self): self._proc.stdout.close() # Kill the process self._proc.kill() + self._proc.wait() + # No need to wait for termination, zombies avoided. self._proc = None @@ -217,7 +219,6 @@ def __readline_and_count(self): if self._debug: if "(error" in buf: raise SolverException(f"Error in smtlib: {buf}") - # lparen, rparen = buf.count("("), buf.count(")") lparen, rparen = map(sum, zip(*((c == "(", c == ")") for c in buf))) return buf, lparen, rparen @@ -229,7 +230,6 @@ def send(self, cmd: str) -> None: """ if self._debug: logger.debug(">%s", cmd) - print(">", cmd) self._proc.stdout.flush() # type: ignore self._proc.stdin.write(f"{cmd}\n") # type: ignore @@ -247,7 +247,6 @@ def recv(self) -> str: if self._debug: logger.debug("<%s", buf) - print("<", buf) return buf @@ -269,6 +268,7 @@ def __init__( support_reset: bool = False, support_minmax: bool = False, support_pushpop: bool = False, + multiple_check: bool = True, debug: bool = False, ): @@ -295,6 +295,7 @@ def __init__( self._support_minmax = support_minmax self._support_reset = support_reset self._support_pushpop = support_pushpop + self._multiple_check = multiple_check if not self._support_pushpop: setattr(self, "_push", None) @@ -307,8 +308,6 @@ def __init__( self._smtlib.start() # run solver specific initializations - for cfg in self._init: - self._smtlib.send(cfg) def _reset(self, constraints: Optional[str] = None) -> None: """Auxiliary method to reset the smtlib external solver to initial defaults""" @@ -411,7 +410,8 @@ def can_be_true(self, constraints: ConstraintSet, expression: Union[bool, Bool] with constraints as temp_cs: temp_cs.add(expression) - return self.can_be_true(temp_cs) + self._reset(temp_cs.to_string()) + return self._is_sat() # get-all-values min max minmax def _optimize_generic(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10000): @@ -432,10 +432,9 @@ def _optimize_generic(self, constraints: ConstraintSet, x: BitVec, goal: str, ma start = time.time() with constraints as temp_cs: - X = temp_cs.new_bitvec(x.size) + X = temp_cs.new_bitvec(x.size) # _getvalue needs a Variable temp_cs.add(X == x) - aux = temp_cs.new_bitvec(X.size, name="optimized_") - self._reset(temp_cs.to_string(related_to=X)) + self._reset(temp_cs.to_string()) # Find one value and use it as currently known min/Max if not self._is_sat(): @@ -446,7 +445,7 @@ def _optimize_generic(self, constraints: ConstraintSet, x: BitVec, goal: str, ma # This uses a binary search to find a suitable range for aux # Use known solution as min or max depending on the goal if goal == "maximize": - m, M = last_value, (1 << x.size) - 1 + m, M = last_value, (1 << X.size) - 1 else: m, M = 0, last_value @@ -466,8 +465,11 @@ def _optimize_generic(self, constraints: ConstraintSet, x: BitVec, goal: str, ma if time.time() - start > consts.timeout: raise SolverError("Timeout") - # reset to before the dichotomic search - self._reset(temp_cs.to_string(related_to=X)) + # reset to before the dichotomic search + with constraints as temp_cs: + X = temp_cs.new_bitvec(x.size) # _getvalue needs a Variable + temp_cs.add(X == x) + self._reset(temp_cs.to_string()) # At this point we know aux is inside [m,M] # Lets constrain it to that range @@ -527,7 +529,7 @@ def get_all_values( ) temp_cs.add(var == expression) - self._reset(temp_cs.to_string(related_to=var)) + self._reset(temp_cs.to_string()) result = [] start = time.time() while self._is_sat(): @@ -546,12 +548,14 @@ def get_all_values( if time.time() - start > consts.timeout: if silent: logger.info("Timeout searching for all solutions") - return result + return list(result) raise SolverError("Timeout") # Sometimes adding a new contraint after a check-sat eats all the mem - temp_cs.add(var != value) - self._reset(temp_cs.to_string(related_to=var)) - # self._assert(var != value) + if self._multiple_check: + self._smtlib.send(f"(assert {translate_to_smtlib(var != value)})") + else: + temp_cs.add(var != value) + self._reset(temp_cs.to_string()) return list(result) def _optimize_fancy(self, constraints: ConstraintSet, x: BitVec, goal: str, max_iter=10000): @@ -572,8 +576,7 @@ def _optimize_fancy(self, constraints: ConstraintSet, x: BitVec, goal: str, max_ X = temp_cs.new_bitvec(x.size) temp_cs.add(X == x) aux = temp_cs.new_bitvec(X.size, name="optimized_") - self._reset(temp_cs.to_string(related_to=X)) - self._smtlib.send(aux.declaration) + self._reset(temp_cs.to_string()) self._assert(operation(X, aux)) self._smtlib.send("(%s %s)" % (goal, aux.name)) @@ -607,7 +610,6 @@ def get_value(self, constraints: ConstraintSet, *expressions): subvar = temp_cs.new_bitvec(expression.value_bits) var.append(subvar) temp_cs.add(subvar == simplify(expression[i])) - self._reset(temp_cs.to_string()) if not self._is_sat(): raise SolverError( @@ -650,44 +652,47 @@ def __init__(self): This is implemented using an external z3 solver (via a subprocess). See https://github.com/Z3Prover/z3 """ - init = [ - # http://smtlib.cs.uiowa.edu/logics-all.shtml#QF_AUFBV - # Closed quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with - # free sort and function symbols. - "(set-logic QF_AUFBV)", - # The declarations and definitions will be scoped - "(set-option :global-decls false)", - # sam.moelius: Option "tactic.solve_eqs.context_solve" was turned on by this commit in z3: - # https://github.com/Z3Prover/z3/commit/3e53b6f2dbbd09380cd11706cabbc7e14b0cc6a2 - # Turning it off greatly improves Manticore's performance on test_integer_overflow_storageinvariant - # in test_consensys_benchmark.py. - "(set-option :tactic.solve_eqs.context_solve false)", - ] command = f"{consts.z3_bin} -t:{consts.timeout * 1000} -memory:{consts.memory} -smt2 -in" - support_minmax, support_reset = self.__autoconfig() + init, support_minmax, support_reset, multiple_check = self.__autoconfig() super().__init__( command=command, init=init, value_fmt=16, - support_minmax=True, - support_reset=True, + support_minmax=support_minmax, + support_reset=support_reset, + multiple_check=multiple_check, support_pushpop=True, debug=False, ) def __autoconfig(self): + init = [ + # http://smtlib.cs.uiowa.edu/logics-all.shtml#QF_AUFBV + # Closed quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with + # free sort and function symbols. + "(set-logic QF_AUFBV)", + # The declarations and definitions will be scoped + "(set-option :global-decls false)", + ] + # To cache what get-info returned; can be directly set when writing tests self.version = self._solver_version() - if self.version >= Version(4, 5, 0): - support_minmax = False - support_reset = False - elif self.version >= Version(4, 4, 1): - support_minmax = True - support_reset = False - else: - logger.debug(" Please install Z3 4.4.1 or newer to get optimization support") - return support_minmax, support_reset + support_reset = True + + if self.version > Version(4, 8, 4): + # sam.moelius: Option "tactic.solve_eqs.context_solve" was turned on by this commit in z3: + # https://github.com/Z3Prover/z3/commit/3e53b6f2dbbd09380cd11706cabbc7e14b0cc6a2 + # Turning it off greatly improves Manticore's performance on test_integer_overflow_storageinvariant + # in test_consensys_benchmark.py. + init.append("(set-option :tactic.solve_eqs.context_solve false)") + + support_minmax = self.version >= Version(4, 4, 1) + + # Certain version of Z3 fails to handle multiple check-sat + # https://gist.github.com/feliam/0f125c00cb99ef05a6939a08c4578902 + multiple_check = self.version < Version(4, 8, 7) + return init, support_minmax, support_reset, multiple_check def _solver_version(self) -> Version: """ diff --git a/manticore/core/smtlib/visitors.py b/manticore/core/smtlib/visitors.py index cbb256e11..eff0d9b58 100644 --- a/manticore/core/smtlib/visitors.py +++ b/manticore/core/smtlib/visitors.py @@ -5,9 +5,10 @@ import copy import logging import operator +import math +from decimal import Decimal logger = logging.getLogger(__name__) -UNSIGN_MASK = (1 << 256) - 1 class Visitor: @@ -51,7 +52,7 @@ def result(self): return self._stack[-1] def _method(self, expression, *args): - for cls in expression.__class__.__mro__: + for cls in expression.__class__.__mro__[:-1]: sort = cls.__name__ methodname = "visit_%s" % sort if hasattr(self, methodname): @@ -72,7 +73,8 @@ def visit(self, node, use_fixed_point=False): :param use_fixed_point: if True, it runs _methods until a fixed point is found :type use_fixed_point: Bool """ - + if isinstance(node, ArrayProxy): + node = node.array cache = self._cache visited = set() stack = [] @@ -285,7 +287,6 @@ def __init__(self, **kw): BitVecAdd: operator.__add__, BitVecSub: operator.__sub__, BitVecMul: operator.__mul__, - BitVecDiv: operator.__floordiv__, BitVecShiftLeft: operator.__lshift__, BitVecShiftRight: operator.__rshift__, BitVecAnd: operator.__and__, @@ -293,21 +294,72 @@ def __init__(self, **kw): BitVecXor: operator.__xor__, BitVecNot: operator.__not__, BitVecNeg: operator.__invert__, - LessThan: operator.__lt__, - LessOrEqual: operator.__le__, - BoolEqual: operator.__eq__, - GreaterThan: operator.__gt__, - GreaterOrEqual: operator.__ge__, BoolAnd: operator.__and__, + BoolEqual: operator.__eq__, BoolOr: operator.__or__, BoolNot: operator.__not__, - BitVecUnsignedDiv: lambda x, y: (x & UNSIGN_MASK) // (y & UNSIGN_MASK), - UnsignedLessThan: lambda x, y: (x & UNSIGN_MASK) < (y & UNSIGN_MASK), - UnsignedLessOrEqual: lambda x, y: (x & UNSIGN_MASK) <= (y & UNSIGN_MASK), - UnsignedGreaterThan: lambda x, y: (x & UNSIGN_MASK) > (y & UNSIGN_MASK), - UnsignedGreaterOrEqual: lambda x, y: (x & UNSIGN_MASK) >= (y & UNSIGN_MASK), + UnsignedLessThan: operator.__lt__, + UnsignedLessOrEqual: operator.__le__, + UnsignedGreaterThan: operator.__gt__, + UnsignedGreaterOrEqual: operator.__ge__, } + def visit_BitVecUnsignedDiv(self, expression, *operands) -> Optional[BitVecConstant]: + if all(isinstance(o, Constant) for o in operands): + a = operands[0].value + b = operands[1].value + if a == 0: + ret = 0 + else: + ret = math.trunc(Decimal(a) / Decimal(b)) + return BitVecConstant(expression.size, ret, taint=expression.taint) + return None + + def visit_LessThan(self, expression, *operands) -> Optional[BoolConstant]: + if all(isinstance(o, Constant) for o in operands): + a = operands[0].signed_value + b = operands[1].signed_value + return BoolConstant(a < b, taint=expression.taint) + return None + + def visit_LessOrEqual(self, expression, *operands) -> Optional[BoolConstant]: + if all(isinstance(o, Constant) for o in operands): + a = operands[0].signed_value + b = operands[1].signed_value + return BoolConstant(a <= b, taint=expression.taint) + return None + + def visit_GreaterThan(self, expression, *operands) -> Optional[BoolConstant]: + if all(isinstance(o, Constant) for o in operands): + a = operands[0].signed_value + b = operands[1].signed_value + return BoolConstant(a > b, taint=expression.taint) + return None + + def visit_GreaterOrEqual(self, expression, *operands) -> Optional[BoolConstant]: + if all(isinstance(o, Constant) for o in operands): + a = operands[0].signed_value + b = operands[1].signed_value + return BoolConstant(a >= b, taint=expression.taint) + return None + + def visit_BitVecDiv(self, expression, *operands) -> Optional[BitVecConstant]: + if all(isinstance(o, Constant) for o in operands): + signmask = operands[0].signmask + mask = operands[0].mask + numeral = operands[0].value + dividend = operands[1].value + if numeral & signmask: + numeral = -(mask - numeral - 1) + if dividend & signmask: + dividend = -(mask - dividend - 1) + if dividend == 0: + result = 0 + else: + result = math.trunc(Decimal(numeral) / Decimal(dividend)) + return BitVecConstant(expression.size, result, taint=expression.taint) + return None + def visit_BitVecConcat(self, expression, *operands): if all(isinstance(o, Constant) for o in operands): result = 0 @@ -989,6 +1041,9 @@ def simplify_array_select(array_exp): def get_variables(expression): + if isinstance(expression, ArrayProxy): + expression = expression.array + visitor = GetDeclarations() visitor.visit(expression) return visitor.result diff --git a/manticore/native/state_merging.py b/manticore/native/state_merging.py index 2ff9f2e64..332f95b73 100644 --- a/manticore/native/state_merging.py +++ b/manticore/native/state_merging.py @@ -32,7 +32,8 @@ def compare_buffers(cs, buffer1, buffer2): if len(buffer1) != len(buffer2): return False for b1, b2 in zip(buffer1, buffer2): - if not SelectedSolver.instance().must_be_true(cs, b1 == b2): + cond = cs.migrate(b1 == b2) + if not SelectedSolver.instance().must_be_true(cs, cond): return False return True @@ -69,7 +70,7 @@ def compare_byte_vals(mem1, mem2, addr, merged_constraint): val2 = mem2.read(addr, 1) # since we only read a single byte value, these lists should only have one entry in them assert len(val1) == 1 and len(val2) == 1 - cond_to_check = val1[0] == val2[0] + cond_to_check = merged_constraint.migrate(val1[0] == val2[0]) if not SelectedSolver.instance().must_be_true(merged_constraint, cond_to_check): return False else: @@ -190,13 +191,20 @@ def merge_cpu(cpu1, cpu2, state, exp1, merged_constraint): if isinstance(val1, BitVec) and isinstance(val2, BitVec): assert val1.size == val2.size if issymbolic(val1) or issymbolic(val2) or val1 != val2: - if SelectedSolver.instance().must_be_true(merged_constraint, val1 != val2): + val1_migrated = merged_constraint.migrate(val1) + val2_migrated = merged_constraint.migrate(val2) + if SelectedSolver.instance().must_be_true( + merged_constraint, val1_migrated != val2_migrated + ): merged_regs.append(reg) if cpu1.regfile.sizeof(reg) == 1: - state.cpu.write_register(reg, Operators.ITE(exp1, val1, val2)) + state.cpu.write_register(reg, Operators.ITE(exp1, val1_migrated, val2_migrated)) else: state.cpu.write_register( - reg, Operators.ITEBV(cpu1.regfile.sizeof(reg), exp1, val1, val2) + reg, + Operators.ITEBV( + cpu1.regfile.sizeof(reg), exp1, val1_migrated, val2_migrated + ), ) return merged_regs diff --git a/manticore/platforms/evm.py b/manticore/platforms/evm.py index 0b85987f4..435c6d83e 100644 --- a/manticore/platforms/evm.py +++ b/manticore/platforms/evm.py @@ -1381,6 +1381,8 @@ def setstate(state, value): def read_buffer(self, offset, size): if issymbolic(size) and not isinstance(size, Constant): raise EVMException("Symbolic size not supported") + if isinstance(size, Constant): + size = size.value if size == 0: return b"" self._allocate(offset, size) diff --git a/manticore/utils/event.py b/manticore/utils/event.py index 82268c33c..2e7e03517 100644 --- a/manticore/utils/event.py +++ b/manticore/utils/event.py @@ -75,15 +75,15 @@ def all_events(cls): return all_evts @staticmethod - def will_did(name): + def will_did(name, can_raise=False): """Pre/pos emiting signal""" def deco(func): @functools.wraps(func) def newFunction(self, *args, **kw): - self._publish(f"will_{name}", *args, **kw) + self._publish(f"will_{name}", *args, can_raise=can_raise, **kw) result = func(self, *args, **kw) - self._publish(f"did_{name}", result) + self._publish(f"did_{name}", result, can_raise=can_raise) return result return newFunction @@ -139,11 +139,17 @@ def _check_event(self, _name): # Wrapper for _publish_impl that also makes sure the event is published from # a class that supports it. # The underscore _name is to avoid naming collisions with callback params - def _publish(self, _name, *args, **kwargs): + def _publish(self, _name, *args, can_raise=True, **kwargs): # only publish if there is at least one subscriber - if _name in self.__sub_events__: - self._check_event(_name) - self._publish_impl(_name, *args, **kwargs) + try: + if _name in self.__sub_events__: + self._check_event(_name) + self._publish_impl(_name, *args, **kwargs) + except Exception as e: + if can_raise: + raise + else: + logger.info("Exception raised at a callback %r", e) # Separate from _publish since the recursive method call to forward an event # shouldn't check the event. diff --git a/manticore/wasm/executor.py b/manticore/wasm/executor.py index 962863ed2..dd6eeede7 100644 --- a/manticore/wasm/executor.py +++ b/manticore/wasm/executor.py @@ -28,6 +28,9 @@ import operator import math +MASK_64 = (1 << 64) - 1 +MASK_32 = (1 << 32) - 1 + class Executor(Eventful): """ @@ -450,14 +453,13 @@ def int_store(self, store, stack, imm: MemoryImm, ty: type, n=None): ) # TODO - Implement a symbolic memory model ea = i + imm.offset N = n if n else (32 if ty is I32 else 64) + mask = (1 << N) - 1 if ea not in mem: raise OutOfBoundsMemoryTrap(ea) if (ea + (N // 8)) - 1 not in mem: raise OutOfBoundsMemoryTrap(ea + (N // 8)) if n: - b = [ - Operators.CHR(Operators.EXTRACT(c % 2 ** N, offset, 8)) for offset in range(0, N, 8) - ] + b = [Operators.CHR(Operators.EXTRACT(c & mask, offset, 8)) for offset in range(0, N, 8)] else: b = [Operators.CHR(Operators.EXTRACT(c, offset, 8)) for offset in range(0, N, 8)] @@ -742,6 +744,17 @@ def i32_clz(self, store, stack): res = Operators.ITEBV(32, flag, res, 32) stack.push(I32.cast(res)) + # value = src.read() + # flag = Operators.EXTRACT(value, 0, 1) == 1 + # res = 0 + # for pos in range(1, src.size): + # res = Operators.ITEBV(dest.size, flag, res, pos) + # flag = Operators.OR(flag, Operators.EXTRACT(value, pos, 1) == 1) + # + # cpu.CF = res == src.size + # cpu.ZF = res == 0 + # dest.write(res) + def i32_ctz(self, store, stack): # Copied from x86 TZCNT stack.has_type_on_top(I32, 1) c1 = stack.pop() @@ -768,19 +781,19 @@ def i32_add(self, store, stack): stack.has_type_on_top(I32, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I32.cast((c2 + c1) % 2 ** 32)) + stack.push(I32.cast((c2 + c1) & MASK_32)) def i32_sub(self, store, stack): stack.has_type_on_top(I32, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I32.cast((c1 - c2 + 2 ** 32) % 2 ** 32)) + stack.push(I32.cast((c1 - c2 + 2 ** 32) & MASK_32)) def i32_mul(self, store, stack): stack.has_type_on_top(I32, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I32.cast((c2 * c1) % 2 ** 32)) + stack.push(I32.cast((c2 * c1) & MASK_32)) def i32_div_s(self, store, stack): stack.has_type_on_top(I32, 2) @@ -850,7 +863,7 @@ def i32_shl(self, store, stack): stack.has_type_on_top(I32, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I32.cast((c1 << (c2 % 32)) % 2 ** 32)) + stack.push(I32.cast((c1 << (c2 % 32)) & MASK_32)) def i32_shr_s(self, store, stack): stack.has_type_on_top(I32, 2) @@ -925,19 +938,19 @@ def i64_add(self, store, stack): stack.has_type_on_top(I64, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I64.cast((c2 + c1) % 2 ** 64)) + stack.push(I64.cast((c2 + c1) & MASK_64)) def i64_sub(self, store, stack): stack.has_type_on_top(I64, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I64.cast((c1 - c2 + 2 ** 64) % 2 ** 64)) + stack.push(I64.cast((c1 - c2 + 2 ** 64) & MASK_64)) def i64_mul(self, store, stack): stack.has_type_on_top(I64, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I64.cast((c2 * c1) % 2 ** 64)) + stack.push(I64.cast((c2 * c1) & MASK_64)) def i64_div_s(self, store, stack): stack.has_type_on_top(I64, 2) @@ -1014,7 +1027,7 @@ def i64_shl(self, store, stack): stack.has_type_on_top(I64, 2) c2 = stack.pop() c1 = stack.pop() - stack.push(I64.cast((c1 << (c2 % 64)) % 2 ** 64)) + stack.push(I64.cast((c1 << (c2 % 64)) & MASK_64)) def i64_shr_s(self, store, stack): stack.has_type_on_top(I64, 2) @@ -1054,7 +1067,7 @@ def i64_rotr(self, store, stack): def i32_wrap_i64(self, store, stack): stack.has_type_on_top(I64, 1) c1: I64 = stack.pop() - c1 %= 2 ** 32 + c1 &= MASK_32 c1 = Operators.EXTRACT(c1, 0, 32) stack.push(I32.cast(c1)) diff --git a/tests/native/test_armv7cpu.py b/tests/native/test_armv7cpu.py index 144c96d95..1b43bfa7e 100644 --- a/tests/native/test_armv7cpu.py +++ b/tests/native/test_armv7cpu.py @@ -1568,7 +1568,7 @@ def test_uqsub8_concrete_saturated(self): @itest_custom("uqsub8 r3, r1, r2") @itest_setregs("R2=0x01010101") def test_uqsub8_sym(self): - op1 = BitVecVariable(32, "op1") + op1 = self.cpu.memory.constraints.new_bitvec(32, "op1") self.cpu.memory.constraints.add(op1 >= 0x04030201) self.cpu.memory.constraints.add(op1 < 0x04030204) self.cpu.R1 = op1 @@ -2416,7 +2416,7 @@ def test_sxth(self): @itest_custom("blx r1") def test_blx_reg_sym(self): - dest = BitVecVariable(32, "dest") + dest = self.cpu.memory.constraints.new_bitvec(32, "dest") self.cpu.memory.constraints.add(dest >= 0x1000) self.cpu.memory.constraints.add(dest <= 0x1001) self.cpu.R1 = dest @@ -2462,7 +2462,7 @@ def test_symbolic_conditional(self): self._setupCpu(asm, mode=CS_MODE_THUMB) # code starts at 0x1004 # Set R0 as a symbolic value - self.cpu.R0 = BitVecVariable(32, "val") + self.cpu.R0 = self.cpu.memory.constraints.new_bitvec(32, "val") self.cpu.execute() # tst r0, r0 self.cpu.execute() # beq label diff --git a/tests/native/test_linux.py b/tests/native/test_linux.py index a12580192..9f9bd3df9 100644 --- a/tests/native/test_linux.py +++ b/tests/native/test_linux.py @@ -285,7 +285,7 @@ def test_armv7_syscall_openat_concrete(self) -> None: def test_armv7_syscall_openat_symbolic(self) -> None: platform, temp_dir = self._armv7_create_openat_state() try: - platform.current.R0 = BitVecVariable(32, "fd") + platform.current.R0 = platform.constraints.new_bitvec(32, "fd") with self.assertRaises(ConcretizeRegister) as cm: platform.syscall() diff --git a/tests/other/data/ErrRelated.pkl.gz b/tests/other/data/ErrRelated.pkl.gz new file mode 100644 index 0000000000000000000000000000000000000000..eb1036567ca2ce788a1c79c0ea6973bfe1b2240d GIT binary patch literal 17638 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 BKM4Q; literal 0 HcmV?d00001 diff --git a/tests/other/test_smtlibv2.py b/tests/other/test_smtlibv2.py index 501d03ee8..c377ddd9e 100644 --- a/tests/other/test_smtlibv2.py +++ b/tests/other/test_smtlibv2.py @@ -1,5 +1,5 @@ import unittest -from unittest.mock import patch, mock_open +import os from manticore.core.smtlib import ( ConstraintSet, @@ -12,15 +12,56 @@ arithmetic_simplify, constant_folder, replace, + BitVecConstant, ) from manticore.core.smtlib.solver import Z3Solver, YicesSolver, CVC4Solver from manticore.core.smtlib.expression import * from manticore.utils.helpers import pickle_dumps +from manticore import config # logging.basicConfig(filename = "test.log", # format = "%(asctime)s: %(name)s:%(levelname)s: %(message)s", # level = logging.DEBUG) +DIRPATH = os.path.dirname(__file__) + + +class RegressionTest(unittest.TestCase): + def test_related_to(self): + import gzip + import pickle, sys + + filename = os.path.abspath(os.path.join(DIRPATH, "data", "ErrRelated.pkl.gz")) + + # A constraint set and a contraint caught in the act of making related_to fail + constraints, constraint = pickle.loads(gzip.open(filename, "rb").read()) + + Z3Solver.instance().can_be_true.cache_clear() + ground_truth = Z3Solver.instance().can_be_true(constraints, constraint) + self.assertEqual(ground_truth, False) + + Z3Solver.instance().can_be_true.cache_clear() + self.assertEqual( + ground_truth, + Z3Solver.instance().can_be_true(constraints.related_to(constraints), constraint), + ) + + # Replace + new_constraint = Operators.UGE( + Operators.SEXTEND(BitVecConstant(256, 0x1A), 256, 512) * BitVecConstant(512, 1), + 0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000, + ) + self.assertEqual(translate_to_smtlib(constraint), translate_to_smtlib(new_constraint)) + + Z3Solver.instance().can_be_true.cache_clear() + self.assertEqual(ground_truth, Z3Solver.instance().can_be_true(constraints, new_constraint)) + + Z3Solver.instance().can_be_true.cache_clear() + self.assertEqual( + ground_truth, + Z3Solver.instance().can_be_true(constraints.related_to(new_constraint), new_constraint), + ) + """ class Z3Specific(unittest.TestCase): @@ -943,9 +984,8 @@ def test_SDIV(self): cs.add(b == 0x86) # -122 cs.add(c == 0x11) # 17 cs.add(a == Operators.SDIV(b, c)) - cs.add(d == b / c) + cs.add(d == (b // c)) cs.add(a == d) - self.assertTrue(solver.check(cs)) self.assertEqual(solver.get_value(cs, a), -7 & 0xFF) @@ -1004,6 +1044,33 @@ def test_NOT(self): self.assertTrue(solver.must_be_true(cs, Operators.NOT(False))) self.assertTrue(solver.must_be_true(cs, Operators.NOT(a == b))) + def testRelated(self): + cs = ConstraintSet() + aa1 = cs.new_bool(name="AA1") + aa2 = cs.new_bool(name="AA2") + bb1 = cs.new_bool(name="BB1") + bb2 = cs.new_bool(name="BB2") + cs.add(Operators.OR(aa1, aa2)) + cs.add(Operators.OR(bb1, bb2)) + self.assertTrue(self.solver.check(cs)) + # No BB variables related to AA + self.assertNotIn("BB", cs.related_to(aa1).to_string()) + self.assertNotIn("BB", cs.related_to(aa2).to_string()) + self.assertNotIn("BB", cs.related_to(aa1 == aa2).to_string()) + self.assertNotIn("BB", cs.related_to(aa1 == False).to_string()) + # No AA variables related to BB + self.assertNotIn("AA", cs.related_to(bb1).to_string()) + self.assertNotIn("AA", cs.related_to(bb2).to_string()) + self.assertNotIn("AA", cs.related_to(bb1 == bb2).to_string()) + self.assertNotIn("AA", cs.related_to(bb1 == False).to_string()) + + # Nothing is related to tautologies? + self.assertEqual("", cs.related_to(simplify(bb1 == bb1)).to_string()) + + # But if the tautollogy can not get simplified we have to ask the solver + # and send in all the other stuff + self.assertNotIn("AA", cs.related_to(bb1 == bb1).to_string()) + def test_API(self): """ As we've split up the Constant, Variable, and Operation classes to avoid using multiple inheritance, @@ -1026,6 +1093,39 @@ def test_API(self): for attr in attrs: self.assertTrue(hasattr(cls, attr), f"{cls.__name__} is missing attribute {attr}") + def test_signed_unsigned_LT_simple(self): + cs = ConstraintSet() + a = cs.new_bitvec(32) + b = cs.new_bitvec(32) + + cs.add(a == 0x1) + cs.add(b == 0x80000000) + + lt = b < a + ult = b.ult(a) + + self.assertFalse(self.solver.can_be_true(cs, ult)) + self.assertTrue(self.solver.must_be_true(cs, lt)) + + def test_signed_unsigned_LT_complex(self): + mask = (1 << 32) - 1 + + cs = ConstraintSet() + _a = cs.new_bitvec(32) + _b = cs.new_bitvec(32) + + cs.add(_a == 0x1) + cs.add(_b == (0x80000000 - 1)) + + a = _a & mask + b = (_b + 1) & mask + + lt = b < a + ult = b.ult(a) + + self.assertFalse(self.solver.can_be_true(cs, ult)) + self.assertTrue(self.solver.must_be_true(cs, lt)) + class ExpressionTestYices(ExpressionTest): def setUp(self): From 166b0415c8bbff477e1425ee83c6a22f5d4451aa Mon Sep 17 00:00:00 2001 From: feliam Date: Mon, 22 Jun 2020 10:42:14 -0300 Subject: [PATCH 12/28] Remove/procrastinate solver query in ether leak detector (#1727) * Remove/procrastinate solver query in etherleak detector * blkn --- manticore/ethereum/detectors.py | 55 ++++++++++++++++++++------------- 1 file changed, 34 insertions(+), 21 deletions(-) diff --git a/manticore/ethereum/detectors.py b/manticore/ethereum/detectors.py index b850ca79a..78340966d 100644 --- a/manticore/ethereum/detectors.py +++ b/manticore/ethereum/detectors.py @@ -177,34 +177,47 @@ def will_evm_execute_instruction_callback(self, state, instruction, arguments): sent_value = arguments[2] msg_sender = state.platform.current_vm.caller - msg = "ether leak" if state.can_be_true(sent_value != 0) else "external call" - if issymbolic(dest_address): # We assume dest_address is symbolic because it came from symbolic tx data (user input argument) - if state.can_be_true(msg_sender == dest_address): + self.add_finding_here( + state, + f"Reachable ether leak to sender via argument", + constraint=AND(msg_sender == dest_address, sent_value != 0), + ) + self.add_finding_here( + state, + f"Reachable external call to sender via argument", + constraint=AND(msg_sender == dest_address, sent_value == 0), + ) + + # ok it can't go to the sender, but can it go to arbitrary addresses? (> 1 other address?) + # we report nothing if it can't go to > 1 other addresses since that means the code constrained + # to a specific address at some point, and that was probably intentional. attacker has basically + # no control. + + possible_destinations = state.solve_n(dest_address, 2) + if len(possible_destinations) > 1: + # This might be a false positive if the dest_address can't actually be solved to anything + # useful/exploitable, even though it can be solved to more than 1 thing self.add_finding_here( state, - f"Reachable {msg} to sender via argument", - constraint=msg_sender == dest_address, + f"Reachable ether leak to user controlled address via argument", + constraint=AND(msg_sender != dest_address, sent_value != 0), ) - else: - # ok it can't go to the sender, but can it go to arbitrary addresses? (> 1 other address?) - # we report nothing if it can't go to > 1 other addresses since that means the code constrained - # to a specific address at some point, and that was probably intentional. attacker has basically - # no control. - - possible_destinations = state.solve_n(dest_address, 2) - if len(possible_destinations) > 1: - # This might be a false positive if the dest_address can't actually be solved to anything - # useful/exploitable, even though it can be solved to more than 1 thing - self.add_finding_here( - state, - f"Reachable {msg} to user controlled address via argument", - constraint=msg_sender != dest_address, - ) + self.add_finding_here( + state, + f"Reachable external call to user controlled address via argument", + constraint=AND(msg_sender != dest_address, sent_value == 0), + ) + else: if msg_sender == dest_address: - self.add_finding_here(state, f"Reachable {msg} to sender", True) + self.add_finding_here( + state, f"Reachable ether leak to sender", constraint=sent_value != 0 + ) + self.add_finding_here( + state, f"Reachable external call to sender", constraint=sent_value == 0 + ) class DetectInvalid(Detector): From 61909a157bd621b273bd5eabd685aef4d7c26af9 Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Tue, 23 Jun 2020 12:09:16 -0700 Subject: [PATCH 13/28] Nightly MacOS Tests (#1614) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Experiment with testing on OSX Not committing to front-lining OSX support as a feature because there are some fundamental performance concerns, but I would like to see how the tests behave. * solc --> usr/local/bin * Don't fail fast * Require Unicorn 1.0.2rc2 ¯\_(ツ)_/¯ * Update Bash on OSX builds * Use mac solc * Simpler solidity installation * Fix wasm tests maybe? * Swap `ls` args in truffle tests * Good 'ol printf debugging * OSX Keystone install * Truffle test miscounting fix? * Add unzipping timeout * Remive timeout _and_ `yes` * Allow output check to work on OSX * Add list wrapper to filter * Remove print statements * yolo keystone via homebrew * Try again w/ Keystone Brew * typo * Create osx.yml * Revert to Master's ci.yml * Update to checkout@v2 universally * Save checkout version change for another PR It maybe breaks codecov? * Add Truffle Tests * Fix Truffle * Make native an option * See if native works? * Revert "See if native works?" This reverts commit ce90d8bcb03e108952b1727d97363ffa24dd77a3. * Replace actions content w/ script * Update number of Truffle tests * Force working directory * Remove shebang, fix YAML * Fix incorrect path to script? * Why are the docs always wrong * YAML syntax * Fix usage of GITHUB_WORKSPACE * Forget the workspace, just copy the script to the root * Revert workspace path changes * Fix VM test generation * Whitespace fixes * Only run on a schedule * Install Yices and CVC4 --- .github/workflows/ci.yml | 172 +--------------------- .github/workflows/osx.yml | 45 ++++++ scripts/run_tests.sh | 171 +++++++++++++++++++++ tests/ethereum/test_regressions.py | 8 +- tests/wasm/generate_tests.sh | 14 +- tests/wasm_sym/generate_symbolic_tests.sh | 14 +- 6 files changed, 243 insertions(+), 181 deletions(-) create mode 100644 .github/workflows/osx.yml create mode 100755 scripts/run_tests.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8aa622fff..73188c3c5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -66,176 +66,8 @@ jobs: env: TEST_TYPE: ${{ matrix.type }} run: | - # Launches all examples; this assumes PWD is examples/script - launch_examples() { - COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc - # concolic assumes presence of ../linux/simpleassert - echo "Running concolic.py..." - HW=../linux/helloworld - coverage run ./concolic.py - if [ $? -ne 0 ]; then - return 1 - fi - - echo "Running count_instructions.py..." - coverage run ./count_instructions.py $HW |grep -q Executed - if [ $? -ne 0 ]; then - return 1 - fi - - echo "Running introduce_symbolic_bytes.py..." - gcc -static -g src/state_explore.c -o state_explore - ADDRESS=0x$(objdump -S state_explore | grep -A 1 '((value & 0xff) != 0)' | - tail -n 1 | sed 's|^\s*||g' | cut -f1 -d:) - coverage run ./introduce_symbolic_bytes.py state_explore $ADDRESS - if [ $? -ne 0 ]; then - return 1 - fi - - echo "Running run_simple.py..." - gcc -x c -static -o hello test_run_simple.c - coverage run ./run_simple.py hello - if [ $? -ne 0 ]; then - return 1 - fi - - echo "Running run_hook.py..." - MAIN_ADDR=$(nm $HW|grep 'T main' | awk '{print "0x"$1}') - coverage run ./run_hook.py $HW $MAIN_ADDR - if [ $? -ne 0 ]; then - return 1 - fi - - echo "Running state_control.py..." - # Straight from the header of state_control.py - gcc -static -g src/state_explore.c -o state_explore - SE_ADDR=0x$(objdump -S state_explore | grep -A 1 'value == 0x41' | - tail -n 1 | sed 's|^\s*||g' | cut -f1 -d:) - coverage run ./state_control.py state_explore $SE_ADDR - if [ $? -ne 0 ]; then - return 1 - fi - - return 0 - } - - make_vmtests(){ - DIR=`pwd` - if [ ! -f ethereum_vm/.done ]; then - echo "Automaking VMTests" `pwd` - cd ./tests/ && mkdir -p ethereum_vm/VMTests_concrete && mkdir -p ethereum_vm/VMTests_symbolic - rm -Rf vmtests; git clone https://github.com/ethereum/tests --depth=1 vmtests - for i in ./vmtests/BlockchainTests/ValidBlocks/VMTests/*/*json; do python ./auto_generators/make_VMTests.py -f istanbul -i $i -o ethereum_vm/VMTests_concrete; done - rm ethereum_vm/VMTests_concrete/test_loop*.py #too slow - rm -rf ./vmtests - touch ethereum_vm/.done - fi - cd $DIR - } - - make_wasm_tests(){ - DIR=`pwd` - if [ ! -f .wasm_done ]; then - echo "Automaking WASM Tests" `pwd` - cd ./tests/wasm - ./generate_tests.sh - touch .wasm_done - fi - cd $DIR - } - - make_wasm_sym_tests(){ - DIR=`pwd` - if [ ! -f .wasm_sym_done ]; then - echo "Automaking Symbolic WASM Tests" `pwd` - cd ./tests/wasm_sym - ./generate_symbolic_tests.sh - touch .wasm_sym_done - fi - cd $DIR - } - - install_truffle(){ - npm install -g truffle - } - - run_truffle_tests(){ - COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc - mkdir truffle_tests - cd truffle_tests - truffle unbox metacoin - coverage run -m manticore . --contract MetaCoin --workspace output --exclude-all --evm.oog ignore --evm.txfail optimistic - # Truffle smoke test. We test if manticore is able to generate states - # from a truffle project. - if [ "$(ls output/*tx -l | wc -l)" != "26" ]; then - echo "Truffle test failed" `ls output/*tx -l | wc -l` "!= 26" - return 1 - fi - echo "Truffle test succeded" - coverage xml - cd .. - cp truffle_tests/coverage.xml . - return 0 - } - - run_tests_from_dir() { - DIR=$1 - COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc - echo "Running only the tests from 'tests/$DIR' directory" - pytest --durations=100 --cov=manticore --cov-config=$GITHUB_WORKSPACE/.coveragerc -n auto "tests/$DIR" - coverage xml - } - - run_examples() { - pushd examples/linux - make - for example in $(make list); do - ./$example < /dev/zero > /dev/null - done - echo Built and ran Linux examples - popd - - pushd examples/script - launch_examples - RESULT=$? - echo Ran example scripts - coverage xml - popd - cp examples/script/coverage.xml . - return $RESULT - } - - # Test type - case $TEST_TYPE in - ethereum_vm) - make_vmtests - run_tests_from_dir $TEST_TYPE - ;; - ethereum_truffle) - echo "Running truffle test" - install_truffle - run_truffle_tests - ;; - wasm) - make_wasm_tests - run_tests_from_dir $TEST_TYPE - ;; - wasm_sym) - make_wasm_sym_tests ;& # Fallthrough - native) ;& # Fallthrough - ethereum) ;& # Fallthrough - ethereum_bench) ;& # Fallthrough - other) - run_tests_from_dir $TEST_TYPE - ;; - examples) - run_examples - ;; - *) - echo "Unknown TEST_TYPE: '$TEST_TYPE'" - exit 3; - ;; - esac + cp scripts/run_tests.sh . + ./run_tests.sh - name: Coverage Upload uses: codecov/codecov-action@v1 with: diff --git a/.github/workflows/osx.yml b/.github/workflows/osx.yml new file mode 100644 index 000000000..5c470e8d4 --- /dev/null +++ b/.github/workflows/osx.yml @@ -0,0 +1,45 @@ +name: MacOS Tests + +on: + schedule: + # Run every day at 11 PM. + - cron: '0 23 * * *' + +jobs: + tests: + runs-on: macos-latest + strategy: + fail-fast: false + matrix: + type: ["ethereum_truffle", "ethereum_bench", "ethereum", "ethereum_vm", "wasm", "wasm_sym", "other"] + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.6 + uses: actions/setup-python@v1 + with: + python-version: 3.6 + - name: Install NPM + uses: actions/setup-node@v1 + with: + node-version: '13.x' + - name: Install dependencies + env: + TEST_TYPE: ${{ matrix.type }} + run: | + EXTRAS="dev-noks" + pip install -e .[$EXTRAS] + - name: Install Mac Dependencies + run: | + brew install bash + brew tap ethereum/ethereum + brew install solidity@4 + brew install wabt + brew install SRI-CSL/sri-csl/yices2 + brew tap cvc4/cvc4 + brew install cvc4/cvc4/cvc4 + - name: Run Tests + env: + TEST_TYPE: ${{ matrix.type }} + run: | + cp scripts/run_tests.sh . + ./run_tests.sh diff --git a/scripts/run_tests.sh b/scripts/run_tests.sh new file mode 100755 index 000000000..ccef31929 --- /dev/null +++ b/scripts/run_tests.sh @@ -0,0 +1,171 @@ +# Launches all examples; this assumes PWD is examples/script +launch_examples() { + COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc + # concolic assumes presence of ../linux/simpleassert + echo "Running concolic.py..." + HW=../linux/helloworld + coverage run ./concolic.py + if [ $? -ne 0 ]; then + return 1 + fi + + echo "Running count_instructions.py..." + coverage run ./count_instructions.py $HW |grep -q Executed + if [ $? -ne 0 ]; then + return 1 + fi + + echo "Running introduce_symbolic_bytes.py..." + gcc -static -g src/state_explore.c -o state_explore + ADDRESS=0x$(objdump -S state_explore | grep -A 1 '((value & 0xff) != 0)' | + tail -n 1 | sed 's|^\s*||g' | cut -f1 -d:) + coverage run ./introduce_symbolic_bytes.py state_explore $ADDRESS + if [ $? -ne 0 ]; then + return 1 + fi + + echo "Running run_simple.py..." + gcc -x c -static -o hello test_run_simple.c + coverage run ./run_simple.py hello + if [ $? -ne 0 ]; then + return 1 + fi + + echo "Running run_hook.py..." + MAIN_ADDR=$(nm $HW|grep 'T main' | awk '{print "0x"$1}') + coverage run ./run_hook.py $HW $MAIN_ADDR + if [ $? -ne 0 ]; then + return 1 + fi + + echo "Running state_control.py..." + # Straight from the header of state_control.py + gcc -static -g src/state_explore.c -o state_explore + SE_ADDR=0x$(objdump -S state_explore | grep -A 1 'value == 0x41' | + tail -n 1 | sed 's|^\s*||g' | cut -f1 -d:) + coverage run ./state_control.py state_explore $SE_ADDR + if [ $? -ne 0 ]; then + return 1 + fi + + return 0 +} + +make_vmtests(){ + DIR=`pwd` + if [ ! -f ethereum_vm/.done ]; then + echo "Automaking VMTests" `pwd` + cd ./tests/ && mkdir -p ethereum_vm/VMTests_concrete && mkdir -p ethereum_vm/VMTests_symbolic + rm -Rf vmtests; git clone https://github.com/ethereum/tests --depth=1 vmtests + for i in ./vmtests/BlockchainTests/ValidBlocks/VMTests/*/*json; do python ./auto_generators/make_VMTests.py -f istanbul -i $i -o ethereum_vm/VMTests_concrete; done + rm ethereum_vm/VMTests_concrete/test_loop*.py #too slow + rm -rf ./vmtests + touch ethereum_vm/.done + fi + cd $DIR +} + +make_wasm_tests(){ + DIR=`pwd` + if [ ! -f .wasm_done ]; then + echo "Automaking WASM Tests" `pwd` + cd ./tests/wasm + ./generate_tests.sh + touch .wasm_done + fi + cd $DIR +} + +make_wasm_sym_tests(){ + DIR=`pwd` + if [ ! -f .wasm_sym_done ]; then + echo "Automaking Symbolic WASM Tests" `pwd` + cd ./tests/wasm_sym + ./generate_symbolic_tests.sh + touch .wasm_sym_done + fi + cd $DIR +} + +install_truffle(){ + npm install -g truffle +} + +run_truffle_tests(){ + COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc + mkdir truffle_tests + cd truffle_tests + truffle unbox metacoin + coverage run -m manticore . --contract MetaCoin --workspace output --exclude-all --evm.oog ignore --evm.txfail optimistic + # Truffle smoke test. We test if manticore is able to generate states + # from a truffle project. + count=$(find output/ -name '*tx' -type f | wc -l) + if [ "$count" -ne 26 ]; then + echo "Truffle test failed" `ls output/*tx -l | wc -l` "!= 26" + return 1 + fi + echo "Truffle test succeded" + coverage xml + cd .. + cp truffle_tests/coverage.xml . + return 0 +} + +run_tests_from_dir() { + DIR=$1 + COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc + echo "Running only the tests from 'tests/$DIR' directory" + pytest --durations=100 --cov=manticore --cov-config=$GITHUB_WORKSPACE/.coveragerc -n auto "tests/$DIR" + coverage xml +} + +run_examples() { + pushd examples/linux + make + for example in $(make list); do + ./$example < /dev/zero > /dev/null + done + echo Built and ran Linux examples + popd + + pushd examples/script + launch_examples + RESULT=$? + echo Ran example scripts + coverage xml + popd + cp examples/script/coverage.xml . + return $RESULT +} + +# Test type +case $TEST_TYPE in + ethereum_vm) + make_vmtests + run_tests_from_dir $TEST_TYPE + ;; + ethereum_truffle) + echo "Running truffle test" + install_truffle + run_truffle_tests + ;; + wasm) + make_wasm_tests + run_tests_from_dir $TEST_TYPE + ;; + wasm_sym) + make_wasm_sym_tests ;& # Fallthrough + native) ;& # Fallthrough + ethereum) ;& # Fallthrough + ethereum_bench) ;& # Fallthrough + other) + run_tests_from_dir $TEST_TYPE + ;; + examples) + run_examples + ;; + *) + echo "Unknown TEST_TYPE: '$TEST_TYPE'" + exit 3; + ;; +esac diff --git a/tests/ethereum/test_regressions.py b/tests/ethereum/test_regressions.py index 26ba1c5d0..f55ff457a 100644 --- a/tests/ethereum/test_regressions.py +++ b/tests/ethereum/test_regressions.py @@ -91,7 +91,13 @@ def test_solidity_timeout(self): output = subprocess.check_output(cmd) end = time.time() - output = output.splitlines() + output = list( + filter( + lambda l: b"Manticore is only supported on Linux. Proceed at your own risk!" + not in l, + output.splitlines(), + ) + ) # Because the run will timeout, we don't know the exact line numbers that will appear # but this seems as a good default diff --git a/tests/wasm/generate_tests.sh b/tests/wasm/generate_tests.sh index 78ec26c59..0b5082bd4 100755 --- a/tests/wasm/generate_tests.sh +++ b/tests/wasm/generate_tests.sh @@ -3,16 +3,20 @@ # rm -rf */ touch __init__.py -wget -nc -nv -O wabt.tgz -c https://github.com/WebAssembly/wabt/releases/download/1.0.12/wabt-1.0.12-linux.tar.gz +if ! [ -x "$(command -v wast2json)" ]; then + wget -nc -nv -O wabt.tgz -c https://github.com/WebAssembly/wabt/releases/download/1.0.12/wabt-1.0.12-linux.tar.gz + tar --wildcards --strip=1 -xf wabt.tgz 'wabt-*/wast2json' + rm wabt.tgz +else + cp "$(command -v wast2json)" . +fi + wget -nc -nv -O spec.zip -c https://github.com/WebAssembly/spec/archive/opam-1.1.zip -yes | unzip -q -j spec.zip 'spec-*/test/core/*' -d . +unzip -q -j spec.zip 'spec-*/test/core/*' -d . rm run.py README.md rm spec.zip -tar --wildcards --strip=1 -xf wabt.tgz 'wabt-*/wast2json' -rm wabt.tgz - mkdir skipped_tests while read skip; do mv $skip.wast skipped_tests/ diff --git a/tests/wasm_sym/generate_symbolic_tests.sh b/tests/wasm_sym/generate_symbolic_tests.sh index 5ee74a883..c0245f05b 100755 --- a/tests/wasm_sym/generate_symbolic_tests.sh +++ b/tests/wasm_sym/generate_symbolic_tests.sh @@ -3,16 +3,20 @@ rm -rf */ touch __init__.py -wget -nc -nv -O wabt.tgz -c https://github.com/WebAssembly/wabt/releases/download/1.0.12/wabt-1.0.12-linux.tar.gz +if ! [ -x "$(command -v wast2json)" ]; then + wget -nc -nv -O wabt.tgz -c https://github.com/WebAssembly/wabt/releases/download/1.0.12/wabt-1.0.12-linux.tar.gz + tar --wildcards --strip=1 -xf wabt.tgz 'wabt-*/wast2json' + rm wabt.tgz +else + cp "$(command -v wast2json)" . +fi + wget -nc -nv -O spec.zip -c https://github.com/WebAssembly/spec/archive/opam-1.1.zip -yes | unzip -q -j spec.zip 'spec-*/test/core/*' -d . +unzip -q -j spec.zip 'spec-*/test/core/*' -d . rm run.py README.md rm spec.zip -tar --wildcards --strip=1 -xf wabt.tgz 'wabt-*/wast2json' -rm wabt.tgz - mkdir skipped_tests while read skip; do mv $skip.wast skipped_tests/ From f39e6ba768c28fb67b31e5158883508a7ba5e1dc Mon Sep 17 00:00:00 2001 From: feliam Date: Fri, 26 Jun 2020 18:12:34 -0300 Subject: [PATCH 14/28] Manticore verifier (#1717) * Add ONE failing test * Fix test * Try fix get-related * Snapshots * CC * Allow snapshooting just from main() * A test * Test and fix is_main * CC * review * ismain vs is_running * is main to is main script * Remove unused member variable * initial import manticore verifier * Fix verifier installation * clear ready states * CC and smoke test * CC * Increase cov * Move regression to other * blkn * blkn * Move get related * CC * fix concolic * lint * DivByZero default to zero * blkn * Update manticore/core/smtlib/solver.py Co-authored-by: Eric Kilmer * Update manticore/core/smtlib/constraints.py Co-authored-by: Eric Kilmer * Update manticore/core/smtlib/constraints.py Co-authored-by: Eric Kilmer * remove odd string * lint * mypy lint * Update manticore/core/smtlib/visitors.py Co-authored-by: Eric Kilmer * lint * Add Docs * blkn * blkn * Replace modulo with masks * Blacken * blkn * fix mypy * fix mypy * Add tests for signed LT behavior * New test * Fix constant folding * lint * blkn * lint * Fixes... * lint * Unittesting power * Permisive read_buffer * Fix optimize * Preserve precision in constant folding * Strip left-in print debugging * blkn * remove wasm_sym temporarily * Better simplification for constants * Add json * blkn * Better commmandline args * blkn * fix wasm * Fix * better commanlining * REmove get_related from the default path and fix arm test * blkn * fix related to tests * blkn * Fix bug in test and disable debug messages in Solver * smtlib config to disable multiple check-sat in newer z3 * Disable log test and fix merging poc vs variable migration * blkn * Avoid exception in some callbacks * can_rais at did_will * yikes! * blkn * Yices found one more states in truffle * Add a config constant to ignore symbolic balances * Add a config constant to ignore symbolic balances 2 * Relax truffle state count * Relax truffle state count 2 * Change cli name and test * Clear redy states in verifier workspace * Clear ready states in verifier workspace * Relative ws path on verifier output. Clean CREATE testcase example * Blkn * Improve coverage and funcid solving * lint * Better testcase generation at verifier * Better testcase generation at verifier and typos * Better output and default re * Test must revert * Better output and default re * move generate_testcase_ex to private method Co-authored-by: Eric Kilmer Co-authored-by: Eric Hennenfent --- manticore/__main__.py | 4 +- manticore/core/manticore.py | 19 +- manticore/core/smtlib/solver.py | 2 +- manticore/core/workspace.py | 8 +- manticore/ethereum/manticore.py | 56 +-- manticore/ethereum/verifier.py | 487 +++++++++++++++++++++ manticore/platforms/evm.py | 45 +- manticore/utils/config.py | 3 +- scripts/run_tests.sh | 4 +- setup.py | 7 +- tests/ethereum/contracts/prop_verifier.sol | 48 ++ tests/ethereum/test_general.py | 62 ++- tests/other/test_smtlibv2.py | 9 + 13 files changed, 677 insertions(+), 77 deletions(-) create mode 100644 manticore/ethereum/verifier.py create mode 100644 tests/ethereum/contracts/prop_verifier.sol diff --git a/manticore/__main__.py b/manticore/__main__.py index 510082925..611487557 100644 --- a/manticore/__main__.py +++ b/manticore/__main__.py @@ -212,9 +212,7 @@ def positive(value): ) eth_flags.add_argument( - "--limit-loops", - action="store_true", - help="Avoid exploring constant functions for human transactions", + "--limit-loops", action="store_true", help="Limit loops depth", ) eth_flags.add_argument( diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index 92abd8c06..f924008ce 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -23,7 +23,7 @@ from ..utils.helpers import PickleSerializer from ..utils.log import set_verbosity from ..utils.nointerrupt import WithKeyboardInterruptAs -from .workspace import Workspace +from .workspace import Workspace, Testcase from .worker import WorkerSingle, WorkerThread, WorkerProcess from multiprocessing.managers import SyncManager @@ -403,8 +403,7 @@ def goto_snapshot(self): in a snapshot """ if not self._snapshot: raise ManticoreError("No snapshot to go to") - for state_id in tuple(self._ready_states): - self._ready_states.remove(state_id) + self.clear_ready_states() for state_id in self._snapshot: self._ready_states.append(state_id) self._snapshot = None @@ -421,13 +420,23 @@ def clear_snapshot(self): @sync @at_not_running def clear_terminated_states(self): - """ Simply remove all states from terminated list """ + """ Remove all states from the terminated list """ terminated_states_ids = tuple(self._terminated_states) for state_id in terminated_states_ids: self._terminated_states.remove(state_id) self._remove(state_id) assert self.count_terminated_states() == 0 + @sync + @at_not_running + def clear_ready_states(self): + """ Remove all states from the ready list """ + ready_states_ids = tuple(self._ready_states) + for state_id in ready_states_ids: + self._ready_states.remove(state_id) + self._remove(state_id) + assert self.count_ready_states() == 0 + def __str__(self): return f"<{str(type(self))[8:-2]}| Alive States: {self.count_ready_states()}; Running States: {self.count_busy_states()} Terminated States: {self.count_terminated_states()} Killed States: {self.count_killed_states()} Started: {self._running.value} Killed: {self._killed.value}>" @@ -833,7 +842,7 @@ def count_terminated_states(self): """ Terminated states count """ return len(self._terminated_states) - def generate_testcase(self, state, message: str = "test", name: str = "test"): + def generate_testcase(self, state, message: str = "test", name: str = "test") -> Testcase: if message == "test" and hasattr(state, "_terminated_by") and state._terminated_by: message = str(state._terminated_by) testcase = self._output.testcase(prefix=name) diff --git a/manticore/core/smtlib/solver.py b/manticore/core/smtlib/solver.py index 9d512c61a..8c312d019 100644 --- a/manticore/core/smtlib/solver.py +++ b/manticore/core/smtlib/solver.py @@ -593,7 +593,7 @@ def get_value(self, constraints: ConstraintSet, *expressions): """ values = [] start = time.time() - with constraints as temp_cs: + with constraints.related_to(*expressions) as temp_cs: for expression in expressions: if not issymbolic(expression): values.append(expression) diff --git a/manticore/core/workspace.py b/manticore/core/workspace.py index 6041ba1ef..2160f2e16 100644 --- a/manticore/core/workspace.py +++ b/manticore/core/workspace.py @@ -44,7 +44,7 @@ def __exit__(self, *excinfo): consts.add("dir", default=".", description="Location of where to create workspace directories") -class WorkspaceTestcase: +class Testcase: """ A `WorkspaceTestCase` represents a test case input generated by Manticore. """ @@ -519,8 +519,8 @@ def __init__(self, desc=None): self._descriptor = desc self._store = Store.fromdescriptor(desc) - def testcase(self, prefix: str = "test") -> WorkspaceTestcase: - return WorkspaceTestcase(self, prefix) + def testcase(self, prefix: str = "test") -> Testcase: + return Testcase(self, prefix) @property def store(self): @@ -587,7 +587,7 @@ def _named_stream(self, name, binary=False, lock=False): yield s # Remove/move ... - def save_testcase(self, state: StateBase, testcase: WorkspaceTestcase, message: str = ""): + def save_testcase(self, state: StateBase, testcase: Testcase, message: str = ""): """ Save the environment from `state` to storage. Return a state id describing it, which should be an int or a string. diff --git a/manticore/ethereum/manticore.py b/manticore/ethereum/manticore.py index 32a0d78a5..1ef66a3f8 100644 --- a/manticore/ethereum/manticore.py +++ b/manticore/ethereum/manticore.py @@ -13,7 +13,8 @@ from crytic_compile import CryticCompile, InvalidCompilation, is_supported -from ..core.manticore import ManticoreBase +from ..core.manticore import ManticoreBase, Testcase, ManticoreError + from ..core.smtlib import ( ConstraintSet, Array, @@ -1536,10 +1537,6 @@ def current_location(self, state): def generate_testcase(self, state, message="", only_if=None, name="user"): """ - Generate a testcase to the workspace for the given program state. The details of what - a testcase is depends on the type of Platform the state is, but involves serializing the state, - and generating an input (concretizing symbolic variables) to trigger this state. - The only_if parameter should be a symbolic expression. If this argument is provided, and the expression *can be true* in this state, a testcase is generated such that the expression will be true in the state. If it *is impossible* for the expression to be true in the state, a testcase is not generated. @@ -1552,29 +1549,38 @@ def generate_testcase(self, state, message="", only_if=None, name="user"): m.generate_testcase(state, 'balance CAN be 0', only_if=balance == 0) # testcase generated with an input that will violate invariant (make balance == 0) + """ + try: + with state as temp_state: + if only_if is not None: + temp_state.constrain(only_if) + return self._generate_testcase_ex(temp_state, message, name=name) + except ManticoreError: + return None + + def _generate_testcase_ex(self, state, message="", name="user"): + """ + Generate a testcase in the outputspace for the given program state. + An exception is raised if the state is unsound or unfeasible + + On return you get a Testcase containing all the informations about the state. + A Testcase is a collection of files living at the OutputSpace. + Registered plugins and other parts of Manticore add files to the Testcase. + User can add more streams to is like this: + + testcase = m.generate_testcase_ex(state) + with testcase.open_stream("txt") as descf: + descf.write("This testcase is interesting!") :param manticore.core.state.State state: :param str message: longer description of the testcase condition - :param manticore.core.smtlib.Bool only_if: only if this expr can be true, generate testcase. if is None, generate testcase unconditionally. - :param str name: short string used as the prefix for the workspace key (e.g. filename prefix for testcase files) - :return: If a testcase was generated + :param str name: short string used as the prefix for the outputspace key (e.g. filename prefix for testcase files) + :return: a Testcase :rtype: bool """ - """ - Create a serialized description of a given state. - :param state: The state to generate information about - :param message: Accompanying message - """ + # Refuse to generate a testcase from an unsound state if not self.fix_unsound_symbolication(state): - return False - - if only_if is not None: - with state as temp_state: - temp_state.constrain(only_if) - if temp_state.is_feasible(): - return self.generate_testcase(temp_state, message, only_if=None, name=name) - else: - return False + raise ManticoreError("Trying to generate a testcase out of an unsound state path") blockchain = state.platform @@ -1584,8 +1590,6 @@ def generate_testcase(self, state, message="", only_if=None, name="user"): testcase = super().generate_testcase( state, message + f"({len(blockchain.human_transactions)} txs)", name=name ) - # TODO(mark): Refactor ManticoreOutput to let the platform be more in control - # so this function can be fully ported to EVMWorld.generate_workspace_files. local_findings = set() for detector in self.detectors.values(): @@ -1865,8 +1869,8 @@ def ready_sound_states(self): This tries to solve any symbolic imprecision added by unsound_symbolication and then iterates over the resultant set. - This is the recommended to iterate over resultant steas after an exploration - that included unsound symbolication + This is the recommended way to iterate over the resultant states after + an exploration that included unsound symbolication """ self.fix_unsound_all() diff --git a/manticore/ethereum/verifier.py b/manticore/ethereum/verifier.py new file mode 100644 index 000000000..702fd0bb6 --- /dev/null +++ b/manticore/ethereum/verifier.py @@ -0,0 +1,487 @@ +""" +$python manticore-verifier.py property.sol TestToken +""" +import os +import re +import sys +import argparse +import logging +import pkg_resources +from itertools import chain +from manticore.ethereum import ManticoreEVM +from manticore.ethereum.detectors import DetectIntegerOverflow +from manticore.ethereum.plugins import FilterFunctions, VerboseTrace, KeepOnlyIfStorageChanges +from manticore.core.smtlib.operators import OR, NOT, AND +from manticore.ethereum.abi import ABI +from manticore.utils.log import set_verbosity +from prettytable import PrettyTable +from manticore.utils import config +from manticore.utils.nointerrupt import WithKeyboardInterruptAs + + +def constrain_to_known_func_ids(state): + world = state.platform + tx = world.human_transactions[-1] + md = state.manticore.get_metadata(tx.address) + + N = 0 + is_normal = False + func_id = tx.data[:4] + for func_hsh in md.function_selectors: + N += 1 + is_normal = OR(func_hsh == func_id, is_normal) + is_fallback = NOT(is_normal) + is_known_func_id = is_normal + + chosen_fallback_func_is = None + if state.can_be_true(is_fallback): + with state as temp_state: + temp_state.constraint(is_fallback) + chosen_fallback_func_id = bytes(state.solve_one(tx.data[:4])) + is_known_func_id = OR(is_known_func_id, chosen_fallback_func_id == func_id) + N += 1 + state.constrain(is_known_func_id) + return N + + +def manticore_verifier( + source_code, + contract_name, + maxfail=None, + maxt=3, + maxcov=100, + deployer=None, + senders=None, + psender=None, + propre=r"crytic_.*", + compile_args=None, + outputspace_url=None, + timeout=100, +): + """ Verify solidity properties + The results are dumped to stdout and to the workspace folder. + + $manticore-verifier property.sol --contract TestToken --smt.solver yices --maxt 4 + # Owner account: 0xf3c67ffb8ab4cdd4d3243ad247d0641cd24af939 + # Contract account: 0x6f4b51ac2eb017600e9263085cfa06f831132c72 + # Sender_0 account: 0x97528a0c7c6592772231fd581e5b42125c1a2ff4 + # PSender account: 0x97528a0c7c6592772231fd581e5b42125c1a2ff4 + # Found 2 properties: crytic_test_must_revert, crytic_test_balance + # Exploration will stop when some of the following happens: + # * 4 human transaction sent + # * Code coverage is greater than 100% meassured on target contract + # * No more coverage was gained in the last transaction + # * At least 2 different properties where found to be breakable. (1 for fail fast) + # * 240 seconds pass + # Starting exploration... + Transactions done: 0. States: 1, RT Coverage: 0.0%, Failing properties: 0/2 + Transactions done: 1. States: 2, RT Coverage: 55.43%, Failing properties: 0/2 + Transactions done: 2. States: 8, RT Coverage: 80.48%, Failing properties: 1/2 + Transactions done: 3. States: 30, RT Coverage: 80.48%, Failing properties: 1/2 + No coverage progress. Stopping exploration. + Coverage obtained 80.48%. (RT + prop) + +-------------------------+------------+ + | Property Named | Status | + +-------------------------+------------+ + | crytic_test_balance | failed (0) | + | crytic_test_must_revert | passed | + +-------------------------+------------+ + Checkout testcases here:./mcore_6jdil7nh + + :param maxfail: stop after maxfail properties are failing. All if None + :param maxcov: Stop after maxcov % coverage is obtained in the main contract + :param maxt: Max transaction count to explore + :param deployer: (optional) address of account used to deploy the contract + :param senders: (optional) a list of calles addresses for the exploration + :param psender: (optional) address from where the property is tested + :param source_code: A filename or source code + :param contract_name: The target contract name defined in the source code + :param propre: A regular expression for selecting properties + :param outputspace_url: where to put the extended result + :param timeout: timeout in seconds + :return: + """ + # Termination condition + # Exploration will stop when some of the following happens: + # * MAXTX human transaction sent + # * Code coverage is greater than MAXCOV meassured on target contract + # * No more coverage was gained in the last transaction + # * At least MAXFAIL different properties where found to be breakable. (1 for fail fast) + + # Max transaction count to explore + MAXTX = maxt + # Max coverage % to get + MAXCOV = maxcov + # Max different properties fails + MAXFAIL = maxfail + + config.get_group("smt").timeout = 120 + config.get_group("smt").memory = 16384 + config.get_group("evm").ignore_balance = True + config.get_group("evm").oog = "ignore" + + print("# Welcome to manticore-verifier") + # Main manticore manager object + m = ManticoreEVM() + # avoid all human level tx that are marked as constant (have no effect on the storage) + filter_out_human_constants = FilterFunctions( + regexp=r".*", depth="human", mutability="constant", include=False + ) + m.register_plugin(filter_out_human_constants) + filter_out_human_constants.disable() + + # Avoid automatically exploring property + filter_no_crytic = FilterFunctions(regexp=propre, include=False) + m.register_plugin(filter_no_crytic) + filter_no_crytic.disable() + + # Only explore properties (at human level) + filter_only_crytic = FilterFunctions(regexp=propre, depth="human", fallback=False, include=True) + m.register_plugin(filter_only_crytic) + filter_only_crytic.disable() + + # And now make the contract account to analyze + + # User accounts. Transactions trying to break the property are send from one + # of this + senders = (None,) if senders is None else senders + + user_accounts = [] + for n, address_i in enumerate(senders): + user_accounts.append( + m.create_account(balance=10 ** 10, address=address_i, name=f"sender_{n}") + ) + # the address used for deployment + owner_account = m.create_account(balance=10 ** 10, address=deployer, name="deployer") + # the target contract account + contract_account = m.solidity_create_contract( + source_code, + owner=owner_account, + contract_name=contract_name, + compile_args=compile_args, + name="contract_account", + ) + # the address used for checking porperties + checker_account = m.create_account(balance=10 ** 10, address=psender, name="psender") + + print(f"# Owner account: 0x{int(owner_account):x}") + print(f"# Contract account: 0x{int(contract_account):x}") + for n, user_account in enumerate(user_accounts): + print(f"# Sender_{n} account: 0x{int(checker_account):x}") + print(f"# PSender account: 0x{int(checker_account):x}") + + properties = {} + md = m.get_metadata(contract_account) + for func_hsh in md.function_selectors: + func_name = md.get_abi(func_hsh)["name"] + if re.match(propre, func_name): + properties[func_name] = [] + + print(f"# Found {len(properties)} properties: {', '.join(properties.keys())}") + if not properties: + print("I am sorry I had to run the init bytecode for this.\n" "Good Bye.") + return + MAXFAIL = len(properties) if MAXFAIL is None else MAXFAIL + tx_num = 0 # transactions count + current_coverage = None # obtained coverge % + new_coverage = 0.0 + + print( + f"""# Exploration will stop when some of the following happens: +# * {MAXTX} human transaction sent +# * Code coverage is greater than {MAXCOV}% meassured on target contract +# * No more coverage was gained in the last transaction +# * At least {MAXFAIL} different properties where found to be breakable. (1 for fail fast) +# * {timeout} seconds pass""" + ) + print("# Starting exploration...") + print( + f"Transactions done: {tx_num}. States: {m.count_ready_states()}, RT Coverage: {0.00}%, " + f"Failing properties: 0/{len(properties)}" + ) + with m.kill_timeout(timeout=timeout): + while True: + # check if we found a way to break more than MAXFAIL properties + broken_properties = sum(int(len(x) != 0) for x in properties.values()) + if broken_properties >= MAXFAIL: + print( + f"Found {broken_properties}/{len(properties)} failing properties. Stopping exploration." + ) + break + + # check if we sent more than MAXTX transaction + if tx_num >= MAXTX: + print("Max numbr of transactions reached({tx_num})") + break + tx_num += 1 + + # check if we got enough coverage + new_coverage = m.global_coverage(contract_account) + if new_coverage >= MAXCOV: + print( + "Current coverage({new_coverage}%) is greater than max allowed({MAXCOV}%).Stopping exploration." + ) + break + + # check if we have made coverage progress in the last transaction + if current_coverage == new_coverage: + print(f"No coverage progress. Stopping exploration.") + break + current_coverage = new_coverage + + # check if timeout was requested + if m.is_killed(): + print("Cancelled or timeout.") + break + + # Explore all methods but the "crytic_" properties + # Note: you may be tempted to get all valid function ids/hashes from the + # metadata and to constrain the first 4 bytes of the calldata here. + # This wont work because we also want to prevent the contract to call + # crytic added methods as internal transactions + filter_no_crytic.enable() # filter out crytic_porperties + filter_out_human_constants.enable() # Exclude constant methods + filter_only_crytic.disable() # Exclude all methods that are not property checks + + symbolic_data = m.make_symbolic_buffer(320) + symbolic_value = m.make_symbolic_value() + caller_account = m.make_symbolic_value(160) + args = tuple((caller_account == address_i for address_i in user_accounts)) + + m.constrain(OR(*args, False)) + m.transaction( + caller=caller_account, + address=contract_account, + value=symbolic_value, + data=symbolic_data, + ) + + m.clear_terminated_states() # no interest in reverted states + m.take_snapshot() # make a copy of all ready states + print( + f"Transactions done: {tx_num}. States: {m.count_ready_states()}, " + f"RT Coverage: {m.global_coverage(contract_account):3.2f}%, " + f"Failing properties: {broken_properties}/{len(properties)}" + ) + + # And now explore all properties (and only the properties) + filter_no_crytic.disable() # Allow crytic_porperties + filter_out_human_constants.disable() # Allow them to be marked as constants + filter_only_crytic.enable() # Exclude all methods that are not property checks + symbolic_data = m.make_symbolic_buffer(4) + m.transaction( + caller=checker_account, address=contract_account, value=0, data=symbolic_data + ) + + for state in m.all_states: + world = state.platform + tx = world.human_transactions[-1] + md = m.get_metadata(tx.address) + """ + A is _broken_ if: + * is normal property + * RETURN False + OR: + * property name ends witth 'revert' + * does not REVERT + Property is considered to _pass_ otherwise + """ + N = constrain_to_known_func_ids(state) + for func_id in map(bytes, state.solve_n(tx.data[:4], nsolves=N)): + func_name = md.get_abi(func_id)["name"] + if not func_name.endswith("revert"): + # Property does not ends in "revert" + # It must RETURN a 1 + if tx.return_value == 1: + # TODO: test when property STOPs + return_data = ABI.deserialize("bool", tx.return_data) + testcase = m.generate_testcase( + state, + f"property {md.get_func_name(func_id)} is broken", + only_if=AND(tx.data[:4] == func_id, return_data == 0), + ) + if testcase: + properties[func_name].append(testcase.num) + else: + # property name ends in "revert" so it MUST revert + if tx.result != "REVERT": + testcase = m.generate_testcase( + state, + f"Some property is broken did not reverted.(MUST REVERTED)", + only_if=tx.data[:4] == func_id, + ) + if testcase: + properties[func_name].append(testcase.num) + + m.clear_terminated_states() # no interest in reverted states for now! + m.goto_snapshot() + + m.clear_terminated_states() + m.clear_ready_states() + m.clear_snapshot() + + if m.is_killed(): + print("Exploration ended by CTRL+C or timeout") + + print(f"Coverage obtained {new_coverage:3.2f}%. (RT + prop)") + + x = PrettyTable() + x.field_names = ["Property Named", "Status"] + for name, testcases in sorted(properties.items()): + result = "passed" + if testcases: + result = f"failed ({testcases[0]})" + x.add_row((name, result)) + print(x) + + m.clear_ready_states() + + workspace = os.path.abspath(m.workspace)[len(os.getcwd()) + 1 :] + print(f"Checkout testcases here:./{workspace}") + + +def main(): + from crytic_compile import is_supported, cryticparser + + parser = argparse.ArgumentParser( + description="Solidity property verifier", + prog="manticore_verifier", + # formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + + # Add crytic compile arguments + # See https://github.com/crytic/crytic-compile/wiki/Configuration + cryticparser.init(parser) + + parser.add_argument( + "source_code", type=str, nargs="*", default=[], help="Contract source code", + ) + parser.add_argument( + "-v", action="count", default=0, help="Specify verbosity level from -v to -vvvv" + ) + + parser.add_argument( + "--workspace", + type=str, + default=None, + help=("A folder name for temporaries and results." "(default mcore_?????)"), + ) + + current_version = pkg_resources.get_distribution("manticore").version + parser.add_argument( + "--version", + action="version", + version=f"Manticore {current_version}", + help="Show program version information", + ) + parser.add_argument( + "--propconfig", type=str, help="Solidity property accounts config file (.yml)", + ) + eth_flags = parser.add_argument_group("Ethereum flags") + + eth_flags.add_argument( + "--quick-mode", + action="store_true", + help="Configure Manticore for quick exploration. Disable gas, generate testcase only for alive states, " + "do not explore constant functions. Disable all detectors.", + ) + eth_flags.add_argument( + "--contract_name", type=str, help="The target contract name defined in the source code" + ) + eth_flags.add_argument( + "--maxfail", type=int, help="stop after maxfail properties are failing. All if None" + ) + eth_flags.add_argument( + "--maxcov", + type=int, + default=100, + help=" Stop after maxcov %% coverage is obtained in the main contract", + ) + eth_flags.add_argument("--maxt", type=int, default=3, help="Max transaction count to explore") + eth_flags.add_argument( + "--deployer", type=str, help="(optional) address of account used to deploy the contract" + ) + eth_flags.add_argument( + "--senders", + type=str, + help="(optional) a comma separated list of sender addresses. The properties are going to be tested sending transactions from these addresses.", + ) + eth_flags.add_argument( + "--psender", type=str, help="(optional) address from where the property is tested" + ) + eth_flags.add_argument( + "--propre", type=str, help="A regular expression for selecting properties" + ) + eth_flags.add_argument( + "--timeout", default=240, type=int, help="Exploration timeout in seconds" + ) + eth_flags.add_argument("--outputspace_url", type=str, help="where to put the extended result") + + config_flags = parser.add_argument_group("Constants") + config.add_config_vars_to_argparse(config_flags) + + parsed = parser.parse_args(sys.argv[1:]) + config.process_config_values(parser, parsed) + + if not parsed.source_code: + print(parser.format_usage() + "error: You need to provide a contract source code.") + sys.exit(1) + args = parsed + set_verbosity(args.v) + logger = logging.getLogger("manticore.main") + + # read yaml config file + deployer = None + senders = None + psenders = None + if args.propconfig: + """ + deployer: "0x41414141414141414141" #who deploys the contract + sender: ["0x51515151515151515151", "0x52525252525252525252"] #who calls the transactions (potentially can be multiple users) + psender: "0x616161616161616161" #who calls the property + """ + import yaml + + with open(args.propconfig) as f: + c = yaml.safe_load(f) + deployer = c.get("deployer") + if deployer is not None: + deployer = int(deployer, 0) + + senders = c.get("sender") + if senders is not None: + senders = [int(sender, 0) for sender in senders] + + psender = c.get("psender") + if psender is not None: + psender = int(psender, 0) + + # override with commandline args + deployer = None + if args.deployer is not None: + deployer = int(args.deployer, 0) + + senders = None + if args.senders is not None: + senders = [int(sender, 0) for sender in args.senders.split(",")] + + psender = None + if args.psender is not None: + psender = int(args.psender, 0) + + source_code = args.source_code[0] + contract_name = args.contract_name + maxfail = args.maxfail + maxt = args.maxt + maxcov = args.maxcov + return manticore_verifier( + source_code, + contract_name, + maxfail=maxfail, + maxt=maxt, + maxcov=100, + senders=senders, + deployer=deployer, + psender=psender, + timeout=args.timeout, + ) diff --git a/manticore/platforms/evm.py b/manticore/platforms/evm.py index 435c6d83e..f65c1cac5 100644 --- a/manticore/platforms/evm.py +++ b/manticore/platforms/evm.py @@ -102,6 +102,10 @@ def globalfakesha3(data): default=-1, description="Max calldata size to explore in each CALLDATACOPY. Iff size in a calldata related instruction are symbolic it will be constrained to be less than this constant. -1 means free(only use when gas is being tracked)", ) +consts.add( + "ignore_balance", default=False, description="Do not try to solve symbolic balances", +) + # Auxiliary constants and functions TT256 = 2 ** 256 @@ -251,6 +255,8 @@ def dump(self, stream, state, mevm, conc_tx=None): stream.write("Gas used: %d %s\n" % (conc_tx.gas, flagged(issymbolic(self.gas)))) tx_data = conc_tx.data + if len(tx_data) > 80: + tx_data = tx_data.rstrip(conc_tx.data[-3:-1]) stream.write( "Data: 0x{} {}\n".format( @@ -262,9 +268,9 @@ def dump(self, stream, state, mevm, conc_tx=None): return_data = conc_tx.return_data stream.write( - "Return_data: 0x{} ({}) {}\n".format( + "Return_data: 0x{} {} {}\n".format( binascii.hexlify(return_data).decode(), - printable_bytes(return_data), + f"({printable_bytes(return_data)})" if conc_tx.sort != "CREATE" else "", flagged(issymbolic(self.return_data)), ) ) @@ -743,7 +749,7 @@ def __init__( # This is a very cornered corner case in which code is actually symbolic # We should simply not allow to jump to unconstrained(*) symbolic code. # (*) bytecode that could take more than a single value - self._check_jumpdest = False + self._need_check_jumpdest = False self._valid_jumpdests = set() # Compile the list of valid jumpdests via linear dissassembly @@ -876,7 +882,7 @@ def __getstate__(self): state["_published_pre_instruction_events"] = self._published_pre_instruction_events state["_used_calldata_size"] = self._used_calldata_size state["_valid_jumpdests"] = self._valid_jumpdests - state["_check_jumpdest"] = self._check_jumpdest + state["_need_check_jumpdest"] = self._need_check_jumpdest state["_return_data"] = self._return_data state["evmfork"] = self.evmfork state["_refund"] = self._refund @@ -905,7 +911,7 @@ def __setstate__(self, state): self.suicides = state["suicides"] self._used_calldata_size = state["_used_calldata_size"] self._valid_jumpdests = state["_valid_jumpdests"] - self._check_jumpdest = state["_check_jumpdest"] + self._need_check_jumpdest = state["_need_check_jumpdest"] self._return_data = state["_return_data"] self.evmfork = state["evmfork"] self._refund = state["_refund"] @@ -1213,23 +1219,23 @@ def _set_check_jmpdest(self, flag=True): Note that at this point `flag` can be the conditional from a JUMPI instruction hence potentially a symbolic value. """ - self._check_jumpdest = flag + self._need_check_jumpdest = flag def _check_jmpdest(self): """ If the previous instruction was a JUMP/JUMPI and the conditional was True, this checks that the current instruction must be a JUMPDEST. - Here, if symbolic, the conditional `self._check_jumpdest` would be + Here, if symbolic, the conditional `self._need_check_jumpdest` would be already constrained to a single concrete value. """ # If pc is already pointing to a JUMPDEST thre is no need to check. pc = self.pc.value if isinstance(self.pc, Constant) else self.pc if pc in self._valid_jumpdests: - self._check_jumpdest = False + self._need_check_jumpdest = False return - should_check_jumpdest = simplify(self._check_jumpdest) + should_check_jumpdest = simplify(self._need_check_jumpdest) if isinstance(should_check_jumpdest, Constant): should_check_jumpdest = should_check_jumpdest.value elif issymbolic(should_check_jumpdest): @@ -1242,7 +1248,7 @@ def _check_jmpdest(self): # If it can be solved only to False just set it False. If it can be solved # only to True, process it and also set it to False - self._check_jumpdest = False + self._need_check_jumpdest = False if should_check_jumpdest: if pc not in self._valid_jumpdests: @@ -3371,21 +3377,24 @@ def dump(self, stream, state, mevm, message): stream.write("\n") # Accounts summary + assert state.can_be_true(True) is_something_symbolic = False stream.write("%d accounts.\n" % len(blockchain.accounts)) for account_address in blockchain.accounts: is_account_address_symbolic = issymbolic(account_address) - account_address = state.solve_one(account_address) + account_address = state.solve_one(account_address, constrain=True) stream.write("* %s::\n" % mevm.account_name(account_address)) stream.write( "Address: 0x%x %s\n" % (account_address, flagged(is_account_address_symbolic)) ) balance = blockchain.get_balance(account_address) - is_balance_symbolic = issymbolic(balance) - is_something_symbolic = is_something_symbolic or is_balance_symbolic - balance = state.solve_one(balance, constrain=True) - stream.write("Balance: %d %s\n" % (balance, flagged(is_balance_symbolic))) + + if not consts.ignore_balance: + is_balance_symbolic = issymbolic(balance) + is_something_symbolic = is_something_symbolic or is_balance_symbolic + balance = state.solve_one(balance, constrain=True) + stream.write("Balance: %d %s\n" % (balance, flagged(is_balance_symbolic))) storage = blockchain.get_storage(account_address) concrete_indexes = set() @@ -3394,7 +3403,7 @@ def dump(self, stream, state, mevm, message): for index in concrete_indexes: stream.write( - f"storage[{index:x}] = {state.solve_one(storage[index], constrain=True):x}" + f"storage[{index:x}] = {state.solve_one(storage[index], constrain=True):x}\n" ) storage = blockchain.get_storage(account_address) stream.write("Storage: %s\n" % translate_to_smtlib(storage, use_bindings=False)) @@ -3420,8 +3429,8 @@ def dump(self, stream, state, mevm, message): stream.write( "storage[%x] = %x %s\n" % ( - state.solve_one(i), - state.solve_one(value), + state.solve_one(i, constrain=True), + state.solve_one(value, constrain=True), flagged(is_storage_symbolic), ) ) diff --git a/manticore/utils/config.py b/manticore/utils/config.py index bd43bd80d..d9f7b4faa 100644 --- a/manticore/utils/config.py +++ b/manticore/utils/config.py @@ -319,7 +319,8 @@ def process_config_values(parser: argparse.ArgumentParser, args: argparse.Namesp :param args: The value that parser.parse_args returned """ # First, load a local config file, if passed or look for one in pwd if it wasn't. - load_overrides(args.config) + if hasattr(args, "config"): + load_overrides(args.config) # Get a list of defined config vals. If these are passed on the command line, # update them in their correct group, not in the cli group diff --git a/scripts/run_tests.sh b/scripts/run_tests.sh index ccef31929..97b71452f 100755 --- a/scripts/run_tests.sh +++ b/scripts/run_tests.sh @@ -100,8 +100,8 @@ run_truffle_tests(){ # Truffle smoke test. We test if manticore is able to generate states # from a truffle project. count=$(find output/ -name '*tx' -type f | wc -l) - if [ "$count" -ne 26 ]; then - echo "Truffle test failed" `ls output/*tx -l | wc -l` "!= 26" + if [ "$count" -lt 25 ]; then + echo "Truffle test failed" `ls output/*tx -l | wc -l` "< 25" return 1 fi echo "Truffle test succeded" diff --git a/setup.py b/setup.py index d40169394..8690299ee 100644 --- a/setup.py +++ b/setup.py @@ -65,6 +65,11 @@ def rtd_dependent_deps(): ] + rtd_dependent_deps(), extras_require=extra_require, - entry_points={"console_scripts": ["manticore = manticore.__main__:main"]}, + entry_points={ + "console_scripts": [ + "manticore = manticore.__main__:main", + "manticore-verifier = manticore.ethereum.verifier:main", + ] + }, classifiers=["License :: OSI Approved :: GNU Affero General Public License v3"], ) diff --git a/tests/ethereum/contracts/prop_verifier.sol b/tests/ethereum/contracts/prop_verifier.sol new file mode 100644 index 000000000..f45bf1746 --- /dev/null +++ b/tests/ethereum/contracts/prop_verifier.sol @@ -0,0 +1,48 @@ +contract Ownership{ + address owner = msg.sender; + function Owner() public{ + owner = msg.sender; + } + modifier isOwner(){ + require(owner == msg.sender); + _; + } +} +contract Pausable is Ownership{ + bool is_paused; + modifier ifNotPaused(){ + require(!is_paused); + _; + } + function paused() isOwner public{ + is_paused = true; + } + function resume() isOwner public{ + is_paused = false; + } +} +contract Token is Pausable{ + mapping(address => uint) public balances; + function transfer(address to, uint value) ifNotPaused public{ + balances[msg.sender] -= value; + balances[to] += value; + } +} + +contract TestToken is Token { + constructor() public{ + balances[msg.sender] = 10000; + } + // the properties + function crytic_test_balance() view public returns(bool){ + return balances[msg.sender] <= 10000; + } + function crytic_test_must_revert() view public returns(bool){ + require(false); + } + function crytic_failing_test_must_revert() view public returns(bool){ + require(true); + } + + +} diff --git a/tests/ethereum/test_general.py b/tests/ethereum/test_general.py index 998aadd8f..c09331a76 100644 --- a/tests/ethereum/test_general.py +++ b/tests/ethereum/test_general.py @@ -1,5 +1,7 @@ import binascii import unittest +import subprocess +import pkg_resources from contextlib import contextmanager from pathlib import Path @@ -27,12 +29,17 @@ ABI, EthereumError, EVMContract, + verifier, ) from manticore.ethereum.plugins import FilterFunctions from manticore.ethereum.solidity import SolidityMetadata from manticore.platforms import evm from manticore.platforms.evm import EVMWorld, ConcretizeArgument, concretized_args, Return, Stop from manticore.utils.deprecated import ManticoreDeprecationWarning +from manticore.utils import config +import io +import contextlib + solver = Z3Solver.instance() @@ -62,6 +69,33 @@ def test_int_ovf(self): self.assertIn("Unsigned integer overflow at MUL instruction", all_findings) +class EthVerifierIntegrationTest(unittest.TestCase): + def test_propverif(self): + smtcfg = config.get_group("smt") + smtcfg.solver = smtcfg.solver.yices + with smtcfg.temp_vals(): + smtcfg.solver = smtcfg.solver.yices + + filename = os.path.join(THIS_DIR, "contracts/prop_verifier.sol") + f = io.StringIO() + with contextlib.redirect_stdout(f): + verifier.manticore_verifier(filename, "TestToken") + output = f.getvalue() + self.assertIsNotNone( + re.compile( + r".*crytic_test_balance\s*\|\s*failed\s*\([0-9a-f]+\).*", re.DOTALL + ).match(output) + ) + self.assertIsNotNone( + re.compile(r".*crytic_test_must_revert\s*\|\s*passed.*", re.DOTALL).match(output) + ) + + def test_propverif_external(self) -> None: + cli_version = subprocess.check_output(("manticore-verifier", "--version")).decode("utf-8") + py_version = f"Manticore {pkg_resources.get_distribution('manticore').version}\n" + self.assertEqual(cli_version, py_version) + + class EthAbiTests(unittest.TestCase): _multiprocess_can_split = True @@ -93,7 +127,7 @@ def test_parse_tx(self): } } """ - user_account = m.create_account(balance=1000000, name="user_account") + user_account = m.create_account(balance=10 ** 10, name="user_account") contract_account = m.solidity_create_contract( source_code, owner=user_account, name="contract_account", gas=36225 ) @@ -684,7 +718,7 @@ def test_function_name_collision(self): def test_check_jumpdest_symbolic_pc(self): """ In Manticore 0.2.4 (up to 6804661) when run with DetectIntegerOverflow, - the EVM.pc is tainted and so it becomes a Constant and so a check in EVM._check_jumpdest: + the EVM.pc is tainted and so it becomes a Constant and so a check in EVM._need_check_jumpdest: self.pc in self._valid_jumpdests failed (because we checked if the object is in a list of integers...). @@ -993,20 +1027,16 @@ class TestPlugin(Plugin): """ def did_evm_execute_instruction_callback(self, state, instruction, arguments, result): - try: - world = state.platform - if world.current_transaction.sort == "CREATE": - name = "init" - else: - name = "rt" - - # collect all end instructions based on whether they are in init or rt - if instruction.is_endtx: - with self.locked_context(name) as d: - d.append(instruction.pc) - except Exception as e: - print(e) - raise + world = state.platform + if world.current_transaction.sort == "CREATE": + name = "init" + else: + name = "rt" + + # collect all end instructions based on whether they are in init or rt + if instruction.is_endtx: + with self.locked_context(name) as d: + d.append(instruction.pc) mevm = self.mevm p = TestPlugin() diff --git a/tests/other/test_smtlibv2.py b/tests/other/test_smtlibv2.py index c377ddd9e..3050b900f 100644 --- a/tests/other/test_smtlibv2.py +++ b/tests/other/test_smtlibv2.py @@ -688,6 +688,15 @@ def test_constant_folding_udiv(self): self.assertItemsEqual(z.taint, ("important", "stuff")) self.assertEqual(z.value, 0x7FFFFFFF) + def test_simplify_OR(self): + cs = ConstraintSet() + bf = BoolConstant(False) + bt = BoolConstant(True) + var = cs.new_bool() + cs.add(simplify(Operators.OR(var, var)) == var) + cs.add(simplify(Operators.OR(var, bt)) == bt) + self.assertTrue(self.solver.check(cs)) + def testBasicReplace(self): """ Add """ a = BitVecConstant(32, 100) From 4712491d379f1fa6c8faa2d38809877e31259f78 Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Fri, 26 Jun 2020 18:54:55 -0700 Subject: [PATCH 15/28] Manticore 0.3.4 (#1720) * Revert 1e23f7ab Remove psutil as a dependency * Bump version numb, update changelog * Re-do updated model not available message * Update for latest PRs * Update dates --- CHANGELOG.md | 55 +++++++++++++++++++++++++++++++-- docs/conf.py | 4 +-- manticore/__main__.py | 5 +-- manticore/core/smtlib/solver.py | 1 - manticore/utils/resources.py | 33 -------------------- mypy.ini | 3 -- setup.py | 3 +- 7 files changed, 57 insertions(+), 47 deletions(-) delete mode 100644 manticore/utils/resources.py diff --git a/CHANGELOG.md b/CHANGELOG.md index c8109bb8a..44d3e7ee0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,59 @@ # Change Log -## [Unreleased](https://github.com/trailofbits/manticore/compare/0.3.3...HEAD) +## [Unreleased](https://github.com/trailofbits/manticore/compare/0.3.4...HEAD) -## 0.3.3 - 2020-01 +## 0.3.4 - 2020-06-26 + +Thanks to our external contributors! + - [jimpo](https://github.com/trailofbits/manticore/commits?author=jimpo) + - [langston-barrett](https://github.com/trailofbits/manticore/commits?author=langston-barrett) + +### Ethereum +* Support and test against EVM Istanbul [#1676](https://github.com/trailofbits/manticore/pull/1676) +* **[Added API]** Added a `manticore-verifier` script for checking properties of smart contracts [#1717](https://github.com/trailofbits/manticore/pull/1717) +* Fixed RETURNDATASIZE [#1612](https://github.com/trailofbits/manticore/pull/1612) +* Added strategies for symbolic SHA3 replacement [#1609](https://github.com/trailofbits/manticore/pull/1609) +* Fixed GAS instruction [#1633](https://github.com/trailofbits/manticore/pull/1633) +* Improved balance-related exploration [#1615](https://github.com/trailofbits/manticore/pull/1615) +* Add `__format__` to EVM accounts [#1613](https://github.com/trailofbits/manticore/pull/1613) +* Discard basic blocks that unavoidably REVERT [#1630](https://github.com/trailofbits/manticore/pull/1630) +* Extract printable bytes from return data [#1671](https://github.com/trailofbits/manticore/pull/1671) +* Support CHAINID, EXTCODEHASH, and SELFBALANCE instructions [#1644](https://github.com/trailofbits/manticore/pull/1644) +* **[Changed API]** Renamed several arguments in EVM API, including `gaslimit` --> `gas` [#1652](https://github.com/trailofbits/manticore/pull/1652) +* Explore states that self-destruct [#1699](https://github.com/trailofbits/manticore/pull/1699) +* Lazy solving for the Ethereum leak detector [#1727](https://github.com/trailofbits/manticore/pull/1727) + +### Native +* Support for ARM modified-immediate encodings [#1638](https://github.com/trailofbits/manticore/pull/1638) +* Support for `/proc/self/maps` [#1639](https://github.com/trailofbits/manticore/pull/1639) +* Support for `llseek` [#1640](https://github.com/trailofbits/manticore/pull/1640) +* Support for `arm_fadvise64_64` [#1648](https://github.com/trailofbits/manticore/pull/1648) +* Allow symbolic sockets in `accept` [#1618](https://github.com/trailofbits/manticore/pull/1618) +* Fixes to `open` [#1657](https://github.com/trailofbits/manticore/pull/1657) +* Overhauled filesystem emulation [#1673](https://github.com/trailofbits/manticore/pull/1673) +* Fixed system call argument concretization [#1697](https://github.com/trailofbits/manticore/pull/1697) +* **[Added API]** Add a symbolic model for `strcpy` [#1681](https://github.com/trailofbits/manticore/pull/1681) + +### WASM +* Delay branch condition concretization for better coverage [#1641](https://github.com/trailofbits/manticore/pull/1641) + +### Other +* **[Added API]** Added a snapshot system [#1710](https://github.com/trailofbits/manticore/pull/1710) +* Transparent compression for state files [#1624](https://github.com/trailofbits/manticore/pull/1624) +* Unify around singleton interface for solver [#1649](https://github.com/trailofbits/manticore/pull/1649) +* Use `__slots__` to reduce memory usage in expression system [#1635](https://github.com/trailofbits/manticore/pull/1635) +* **[Removed API]** Removed `policy` argument from ManticoreBase, added `outputspace_url` to optionally separate working files from output files [#1651](https://github.com/trailofbits/manticore/pull/1651) +* Disable broken `get_related` logic [#1674](https://github.com/trailofbits/manticore/pull/1674) +* Disable flaky Z3 tactics [#1691](https://github.com/trailofbits/manticore/pull/1691) +* Remove Keystone engine from dependencies [#1684](https://github.com/trailofbits/manticore/pull/1684) +* Improved error messages [#1632](https://github.com/trailofbits/manticore/pull/1632), [#1704](https://github.com/trailofbits/manticore/pull/1704) +* Made ConstraintSets hashable [#1703](https://github.com/trailofbits/manticore/pull/1703) +* Added system to dynamically enable/disable plugins [#1696](https://github.com/trailofbits/manticore/pull/1696) [#1708](https://github.com/trailofbits/manticore/pull/1708) +* Re-establish support for Yices and CVC4 [#1714](https://github.com/trailofbits/manticore/pull/1714) +* Improved constant folding and constraint set slicing [#1706](https://github.com/trailofbits/manticore/pull/1706) + + +## 0.3.3 - 2020-01-30 Thanks to our external contributors! diff --git a/docs/conf.py b/docs/conf.py index e537d40cd..e8dcff8d5 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -54,9 +54,9 @@ # built documents. # # The short X.Y version. -version = "0.3.3" +version = "0.3.4" # The full version, including alpha/beta/rc tags. -release = "0.3.3" +release = "0.3.4" # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/manticore/__main__.py b/manticore/__main__.py index 611487557..12d553465 100644 --- a/manticore/__main__.py +++ b/manticore/__main__.py @@ -11,7 +11,7 @@ from .core.manticore import ManticoreBase, set_verbosity from .ethereum.cli import ethereum_main from .wasm.cli import wasm_main -from .utils import config, log, install_helper, resources +from .utils import config, log, install_helper consts = config.get_group("main") consts.add("recursionlimit", default=10000, description="Value to set for Python recursion limit") @@ -38,9 +38,6 @@ def main() -> None: set_verbosity(args.v) - resources.check_disk_usage() - resources.check_memory_usage() - if args.argv[0].endswith(".sol") or is_supported(args.argv[0]): ethereum_main(args, logger) elif args.argv[0].endswith(".wasm") or args.argv[0].endswith(".wat"): diff --git a/manticore/core/smtlib/solver.py b/manticore/core/smtlib/solver.py index 8c312d019..c12de91e7 100644 --- a/manticore/core/smtlib/solver.py +++ b/manticore/core/smtlib/solver.py @@ -30,7 +30,6 @@ from .visitors import * from ...exceptions import Z3NotFoundError, SolverError, SolverUnknown, TooManySolutions, SmtlibError from ...utils import config -from ...utils.resources import check_memory_usage, check_disk_usage from . import issymbolic diff --git a/manticore/utils/resources.py b/manticore/utils/resources.py deleted file mode 100644 index 6ae1ff1f5..000000000 --- a/manticore/utils/resources.py +++ /dev/null @@ -1,33 +0,0 @@ -import logging -from psutil import disk_usage, virtual_memory - -logger = logging.getLogger(__name__) -logger.setLevel(logging.INFO) - -#: Percentage of _used_ memory to warn above -memory_warn_percent = 95.0 -#: Number of free bytes to warn below -memory_warn_absolute = (1024 ** 3) // 2 -#: Number of free bytes to warn below -disk_warn = 1024 ** 3 - - -def check_memory_usage(): - """ - Print a warning message if the available memory space is below memory_warn - """ - usage = virtual_memory() - if usage.percent >= 95.0 or usage.available < memory_warn_absolute: - logger.warning( - "System only has %d kib of virtual memory available", usage.available // 1024 - ) - - -def check_disk_usage(path="."): - """ - Print a warning message if the available disk space is below disk_warn - :param path: System path to check. Defaults to the current directory. - """ - usage = disk_usage(path) - if usage.free < (disk_warn): - logger.warning("Only %d kib of disk space remaining", usage.free // 1024) diff --git a/mypy.ini b/mypy.ini index 82669511c..7f7279360 100644 --- a/mypy.ini +++ b/mypy.ini @@ -39,6 +39,3 @@ ignore_missing_imports = True [mypy-wasm.*] ignore_missing_imports = True - -[mypy-psutil.*] -ignore_missing_imports = True diff --git a/setup.py b/setup.py index 8690299ee..b644c87a2 100644 --- a/setup.py +++ b/setup.py @@ -48,7 +48,7 @@ def rtd_dependent_deps(): long_description_content_type="text/markdown", url="https://github.com/trailofbits/manticore", author="Trail of Bits", - version="0.3.3", + version="0.3.4", packages=find_packages(exclude=["tests", "tests.*"]), python_requires=">=3.6", install_requires=[ @@ -61,7 +61,6 @@ def rtd_dependent_deps(): "wasm", "dataclasses; python_version < '3.7'", "pyevmasm>=0.2.3", - "psutil", ] + rtd_dependent_deps(), extras_require=extra_require, From a2f072f822ef5833920f4b39cee914070367d840 Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Tue, 30 Jun 2020 11:15:03 -0700 Subject: [PATCH 16/28] Enable nightly uploads to PyPI (#1757) * Add Github Actions config * Handle nightly versioning * Fix typos in README and PyPI upload * Make image URL global * Attempt today's upload * Install wheel * Fix indentation * Only run on schedule * Use versioned action, add nightly to readme * Retest upload w/ hard-coded version * Apparently v1 doesn't parse * Revert to only scheduled --- .github/workflows/ci.yml | 22 +++++++++++++++++++++- README.md | 18 ++++++++++++------ setup.py | 13 +++++++++++-- 3 files changed, 44 insertions(+), 9 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 73188c3c5..7bc009862 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -75,5 +75,25 @@ jobs: file: ./coverage.xml yml: ./codecov.yml # Disabled this line because Codecov has been extra flaky lately, and having to re-run the entire -# test suite until every coverage upload step succeeds is more of a hassle than it's worth. +# test suite until every coverage upload step succeeds is more of a hassle than it's worth. # fail_ci_if_error: true + upload: + runs-on: ubuntu-latest + if: github.event_name == 'schedule' + needs: tests + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.6 + uses: actions/setup-python@v1 + with: + python-version: 3.6 + - name: Build Dist + run: | + python3 -m pip install wheel + python3 setup.py --dev_release sdist bdist_wheel + - name: Upload to PyPI + uses: pypa/gh-action-pypi-publish@v1.2.2 + with: + password: ${{ secrets.PYPI_UPLOAD }} + + diff --git a/README.md b/README.md index bc65bb997..15e92ad20 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Manticore

- +


@@ -46,7 +46,13 @@ Option 2: Installing from PyPI, with extra dependencies needed to execute native pip install "manticore[native]" ``` -Option 3: Installing from the `master` branch: +Option 3: Installing a nightly development build (fill in the latest version from [the PyPI history](https://pypi.org/project/manticore/#history)): + +```bash +pip install "manticore[native]==0.x.x.devYYMMDD" +``` + +Option 4: Installing from the `master` branch: ```bash git clone https://github.com/trailofbits/manticore.git @@ -54,7 +60,7 @@ cd manticore pip install -e ".[native]" ``` -Option 4: Install via Docker: +Option 5: Install via Docker: ```bash docker pull trailofbits/manticore @@ -216,9 +222,9 @@ for idx, val_list in enumerate(m.collect_returns()): * We're still in the process of implementing full support for the EVM Istanbul instruction semantics, so certain opcodes may not be supported. In a pinch, you can try compiling with Solidity 0.4.x to avoid generating those instructions. -## Using a different solverr (Z3, Yices, CVC4) -Manticore relies on an external solver supporting smtlib2. Curently Z3, Yices and CVC4 are supported and can be selected via commandline or configuration settings. -By default Manticore will use Z3. Once you installed a different solver you can choose a different solver like this: +## Using a different solver (Z3, Yices, CVC4) +Manticore relies on an external solver supporting smtlib2. Currently Z3, Yices and CVC4 are supported and can be selected via commandline or configuration settings. +By default Manticore will use Z3. Once you've installed a different solver, you can choose which one to use like this: ```manticore --smt.solver yices``` ### Installing CVC4 For more details go to https://cvc4.github.io/. Otherwise just get the binary and use it. diff --git a/setup.py b/setup.py index b644c87a2..a5076da94 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,7 @@ import os +import sys from setuptools import setup, find_packages +from datetime import date on_rtd = os.environ.get("READTHEDOCS") == "True" @@ -41,14 +43,21 @@ def rtd_dependent_deps(): with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f: long_description = f.read() + +# https://stackoverflow.com/a/4792601 grumble grumble +dev_extension = "" +if "--dev_release" in sys.argv: + dev_extension = ".dev" + date.today().strftime("%y%m%d") + sys.argv.remove("--dev_release") + setup( name="manticore", description="Manticore is a symbolic execution tool for analysis of binaries and smart contracts.", - long_description=long_description, long_description_content_type="text/markdown", + long_description=long_description, url="https://github.com/trailofbits/manticore", author="Trail of Bits", - version="0.3.4", + version="0.3.4" + dev_extension, packages=find_packages(exclude=["tests", "tests.*"]), python_requires=">=3.6", install_requires=[ From e265bceae639418453736faa40a2ac6bea04f339 Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 30 Jun 2020 15:15:54 -0300 Subject: [PATCH 17/28] Specialized iterative serialization for Array (#1756) * Specialized itereative serialization for Array * lint --- manticore/core/smtlib/expression.py | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/manticore/core/smtlib/expression.py b/manticore/core/smtlib/expression.py index 39838f015..f63a5c1de 100644 --- a/manticore/core/smtlib/expression.py +++ b/manticore/core/smtlib/expression.py @@ -966,6 +966,27 @@ def index(self): def value(self): return self.operands[2] + def __getstate__(self): + state = {} + array = self + items = [] + while isinstance(array, ArrayStore): + items.append((array.index, array.value)) + array = array.array + state["_array"] = array + state["_items"] = items + return state + + def __setstate__(self, state): + array = state["_array"] + for index, value in reversed(state["_items"][0:]): + array = array.store(index, value) + self._index_bits = array.index_bits + self._index_max = array.index_max + self._value_bits = array.value_bits + index, value = state["_items"][0] + self._operands = (array, index, value) + class ArraySlice(ArrayOperation): def __init__( @@ -1126,7 +1147,6 @@ def __getstate__(self): state["_array"] = self._array state["name"] = self.name state["_concrete_cache"] = self._concrete_cache - state["_written"] = self._written return state def __setstate__(self, state): @@ -1134,7 +1154,7 @@ def __setstate__(self, state): self._array = state["_array"] self._name = state["name"] self._concrete_cache = state["_concrete_cache"] - self._written = state["_written"] + self._written = None def __copy__(self): return ArrayProxy(self) From 7d26c9d5b4af2256a98d06563d678141476bb6f0 Mon Sep 17 00:00:00 2001 From: feliam Date: Mon, 6 Jul 2020 12:46:57 -0300 Subject: [PATCH 18/28] Typo (#1768) --- manticore/ethereum/verifier.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/manticore/ethereum/verifier.py b/manticore/ethereum/verifier.py index 702fd0bb6..d156ac911 100644 --- a/manticore/ethereum/verifier.py +++ b/manticore/ethereum/verifier.py @@ -282,7 +282,7 @@ def manticore_verifier( * is normal property * RETURN False OR: - * property name ends witth 'revert' + * property name ends with 'revert' * does not REVERT Property is considered to _pass_ otherwise """ From 14ef9ec0991fbc49aeeabf1ad9ff9ab226e48dd8 Mon Sep 17 00:00:00 2001 From: sschriner <60201678+sschriner@users.noreply.github.com> Date: Tue, 7 Jul 2020 13:25:13 -0400 Subject: [PATCH 19/28] New working model of strlen (#1725) * New working model of strlen - Symbolic Test yet to be updated * Updated modeling test for all symbolic input * Fixed code climate issue * Adding binary for new test * Updated test to use sets for compairison * Removed length compairison * Fix argument concretization indexing * Preserve both model implementation strategies * Corrected formatting * Removed whitespace for code climate * Removed whitespace for code climate Co-authored-by: Eric Kilmer --- manticore/native/models.py | 152 ++++++++++++++---------- tests/native/binaries/sym_strlen_test | Bin 0 -> 847440 bytes tests/native/binaries/sym_strlen_test.c | 14 +++ tests/native/test_models.py | 83 +++++++++++-- 4 files changed, 176 insertions(+), 73 deletions(-) create mode 100755 tests/native/binaries/sym_strlen_test create mode 100644 tests/native/binaries/sym_strlen_test.c diff --git a/manticore/native/models.py b/manticore/native/models.py index 699a86be0..6f5a67407 100644 --- a/manticore/native/models.py +++ b/manticore/native/models.py @@ -34,7 +34,50 @@ def variadic(func): return func -def _find_zero(cpu, constrs, ptr): +def is_definitely_NULL(byte, constrs) -> bool: + """ + Checks if a given byte read from memory is NULL. + This supports both concrete & symbolic byte values. + + :param byte: byte read from memory to be examined + :param constrs: state constraints + :return: whether a given byte is NULL or constrained to NULL + """ + if issymbolic(byte): + return SelectedSolver.instance().must_be_true(constrs, byte == 0) + else: + return byte == 0 + + +def cannot_be_NULL(byte, constrs) -> bool: + """ + Checks if a given byte read from memory is not NULL or cannot be NULL + + :param byte: byte read from memory to be examined + :param constrs: state constraints + :return: whether a given byte is not NULL or cannot be NULL + """ + if issymbolic(byte): + return SelectedSolver.instance().must_be_true(constrs, byte != 0) + else: + return byte != 0 + + +def can_be_NULL(byte, constrs) -> bool: + """ + Checks if a given byte read from memory can be NULL + + :param byte: byte read from memory to be examined + :param constrs: state constraints + :return: whether a given byte is NULL or can be NULL + """ + if issymbolic(byte): + return SelectedSolver.instance().can_be_true(constrs, byte == 0) + else: + return byte == 0 + + +def _find_zero(cpu, constrs, ptr: Union[int, BitVec]) -> int: """ Helper for finding the closest NULL or, effectively NULL byte from a starting address. @@ -46,15 +89,9 @@ def _find_zero(cpu, constrs, ptr): offset = 0 while True: - byt = cpu.read_int(ptr + offset, 8) - - if issymbolic(byt): - if not SelectedSolver.instance().can_be_true(constrs, byt != 0): - break - else: - if byt == 0: - break - + byte = cpu.read_int(ptr + offset, 8) + if is_definitely_NULL(byte, constrs): + break offset += 1 return offset @@ -78,7 +115,7 @@ def strcmp(state: State, s1: Union[int, BitVec], s2: Union[int, BitVec]): been tracking and just replace it with the symbolic subtraction of the two - :param State state: Current program state + :param state: Current program state :param s1: Address of string 1 :param s2: Address of string 2 :return: Symbolic strcmp result @@ -116,76 +153,71 @@ def strcmp(state: State, s1: Union[int, BitVec], s2: Union[int, BitVec]): return ret -def strlen(state: State, s: Union[int, BitVec]) -> Union[int, BitVec]: +def strlen_exact(state: State, s: Union[int, BitVec]) -> Union[int, BitVec]: """ - strlen symbolic model. + strlen symbolic model - Algorithm: Walks from end of string not including NULL building ITE tree when current byte is symbolic. + Strategy: produce a state for every symbolic string length for better accuracy - :param State state: current program state + Algorithm: Counts the number of characters in a string forking every time a symbolic byte + is found that can be NULL but is not constrained to NULL. + + :param state: current program state :param s: Address of string :return: Symbolic strlen result - :rtype: Expression or int """ - cpu = state.cpu - if issymbolic(s): raise ConcretizeArgument(state.cpu, 1) - zero_idx = _find_zero(cpu, state.constraints, s) + cpu = state.cpu + constrs = state.constraints - ret = zero_idx + # Initialize offset based on whether state has been forked in strlen + if "strlen" not in state.context: + offset = 0 + else: + offset = state.context["strlen"] - for offset in range(zero_idx - 1, -1, -1): - byt = cpu.read_int(s + offset, 8) - if issymbolic(byt): - ret = ITEBV(cpu.address_bit_size, byt == 0, offset, ret) + c = cpu.read_int(s + offset, 8) + while not is_definitely_NULL(c, constrs): + # If the byte can be NULL concretize and fork states + if can_be_NULL(c, constrs): + state.context["strlen"] = offset + raise Concretize("Forking on possible NULL strlen", expression=(c == 0), policy="ALL") - return ret + offset += 1 + c = cpu.read_int(s + offset, 8) + return offset -def is_definitely_NULL(byte, constrs) -> bool: - """ - Checks if a given byte read from memory is NULL. - This supports both concrete & symbolic byte values. - :param byte: byte read from memory to be examined - :param constrs: state constraints - :return: whether a given byte is NULL or constrained to NULL +def strlen_approx(state: State, s: Union[int, BitVec]) -> Union[int, BitVec]: """ - if issymbolic(byte): - return SelectedSolver.instance().must_be_true(constrs, byte == 0) - else: - return byte == 0 + strlen symbolic model + Strategy: build a result tree to limit state explosion results approximate -def cannot_be_NULL(byte, constrs) -> bool: + Algorithm: Walks from end of string not including NULL building ITE tree when current byte is symbolic. + :param state: current program state + :param s: Address of string + :return: Symbolic strlen result """ - Checks if a given byte read from memory is not NULL or cannot be NULL - :param byte: byte read from memory to be examined - :param constrs: state constraints - :return: whether a given byte is not NULL or cannot be NULL - """ - if issymbolic(byte): - return SelectedSolver.instance().must_be_true(constrs, byte != 0) - else: - return byte != 0 + if issymbolic(s): + raise ConcretizeArgument(state.cpu, 1) + cpu = state.cpu + zero_idx = _find_zero(cpu, state.constraints, s) -def can_be_NULL(byte, constrs) -> bool: - """ - Checks if a given byte read from memory can be NULL + ret = zero_idx - :param byte: byte read from memory to be examined - :param constrs: state constraints - :return: whether a given byte is NULL or can be NULL - """ - if issymbolic(byte): - return SelectedSolver.instance().can_be_true(constrs, byte == 0) - else: - return byte == 0 + for offset in range(zero_idx - 1, -1, -1): + byt = cpu.read_int(s + offset, 8) + if issymbolic(byt): + ret = ITEBV(cpu.address_bit_size, byt == 0, offset, ret) + + return ret def strcpy(state: State, dst: Union[int, BitVec], src: Union[int, BitVec]) -> Union[int, BitVec]: @@ -202,10 +234,10 @@ def strcpy(state: State, dst: Union[int, BitVec], src: Union[int, BitVec]) -> Un :return: pointer to the dst """ if issymbolic(src): - raise ConcretizeArgument(state.cpu, 1) + raise ConcretizeArgument(state.cpu, 2) if issymbolic(dst): - raise ConcretizeArgument(state.cpu, 0) + raise ConcretizeArgument(state.cpu, 1) cpu = state.cpu constrs = state.constraints @@ -222,7 +254,7 @@ def strcpy(state: State, dst: Union[int, BitVec], src: Union[int, BitVec]) -> Un while not is_definitely_NULL(src_val, constrs): cpu.write_int(dst + offset, src_val, 8) - # If a byte can be NULL set the src_val for concretize and fork states + # If a src byte can be NULL concretize and fork states if can_be_NULL(src_val, constrs): state.context["strcpy"] = offset raise Concretize("Forking on NULL strcpy", expression=(src_val == 0), policy="ALL") diff --git a/tests/native/binaries/sym_strlen_test b/tests/native/binaries/sym_strlen_test new file mode 100755 index 0000000000000000000000000000000000000000..4fc79ab81034faac14faff3e7b601c8306b5d7df GIT binary patch literal 847440 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±t`Pos49(bCF=Cuz_-*ha)(m)dh3ud7F( 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 +#include +#include +#define LEN 5 + +int main() { + char str[LEN]; + read(0, str, sizeof(str)); + + int a = strlen(str); + printf("Length of string is: %d", a); + + return 0; +} diff --git a/tests/native/test_models.py b/tests/native/test_models.py index f33b19f18..ae718c7f7 100644 --- a/tests/native/test_models.py +++ b/tests/native/test_models.py @@ -20,7 +20,8 @@ variadic, isvariadic, strcmp, - strlen, + strlen_exact, + strlen_approx, strcpy, is_definitely_NULL, cannot_be_NULL, @@ -160,72 +161,128 @@ def test_symbolic_concrete(self): class StrlenTest(ModelTest): def test_concrete(self): s = self._push_string("abc\0") - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertEqual(ret, 3) + ret = strlen_approx(self.state, s) self.assertEqual(ret, 3) def test_concrete_empty(self): s = self._push_string("\0") - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertEqual(ret, 0) + ret = strlen_approx(self.state, s) self.assertEqual(ret, 0) def test_symbolic_effective_null(self): sy = self.state.symbolicate_buffer("ab+") self.state.constrain(sy[2] == 0) s = self._push_string(sy) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertEqual(ret, 2) + ret = strlen_approx(self.state, s) self.assertEqual(ret, 2) - def test_symbolic(self): + def test_symbolic_no_fork(self): sy = self.state.symbolicate_buffer("+++\0") s = self._push_string(sy) - ret = strlen(self.state, s) + ret = strlen_approx(self.state, s) self.assertItemsEqual( range(4), Z3Solver.instance().get_all_values(self.state.constraints, ret) ) self.state.constrain(sy[0] == 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 0)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 0)) self._clear_constraints() self.state.constrain(sy[0] != 0) self.state.constrain(sy[1] == 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 1)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 1)) self._clear_constraints() self.state.constrain(sy[0] != 0) self.state.constrain(sy[1] != 0) self.state.constrain(sy[2] == 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 2)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 2)) self._clear_constraints() self.state.constrain(sy[0] != 0) self.state.constrain(sy[1] != 0) self.state.constrain(sy[2] != 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 3)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 3)) + def test_symbolic_fork(self): + # This binary is compiled using gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 + # with flags: -g -static -fno-builtin + BIN_PATH = os.path.join(os.path.dirname(__file__), "binaries", "sym_strlen_test") + tmp_dir = tempfile.TemporaryDirectory(prefix="mcore_test_sym_") + m = Manticore(BIN_PATH, stdin_size=10, workspace_url=str(tmp_dir.name)) + + addr_of_strlen = 0x04404D0 + + @m.hook(addr_of_strlen) + def strlen_model(state): + state.invoke_model(strlen_exact) + + m.run() + m.finalize() + + # Expected stdout outputs + expected = { + "Length of string is: 0", + "Length of string is: 1", + "Length of string is: 2", + "Length of string is: 3", + "Length of string is: 4", + "Length of string is: 5", + } + + # Make a list of the generated output states + outputs = f"{str(m.workspace)}/test_*.stdout" + stdouts = set() + for out in glob(outputs): + with open(out) as f: + stdouts.add(f.read()) + + # Assert that every expected stdout has a matching output + self.assertEqual(expected, stdouts) + def test_symbolic_mixed(self): sy = self.state.symbolicate_buffer("a+b+\0") s = self._push_string(sy) self.state.constrain(sy[1] == 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 1)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 1)) self._clear_constraints() self.state.constrain(sy[1] != 0) self.state.constrain(sy[3] == 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 3)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 3)) self._clear_constraints() self.state.constrain(sy[1] != 0) self.state.constrain(sy[3] != 0) - ret = strlen(self.state, s) + ret = strlen_exact(self.state, s) + self.assertTrue(self.state.must_be_true(ret == 4)) + ret = strlen_approx(self.state, s) self.assertTrue(self.state.must_be_true(ret == 4)) From 2ce7bb88d5ba007a8d323db3d3fa5da37662f97b Mon Sep 17 00:00:00 2001 From: wolflo Date: Thu, 9 Jul 2020 18:37:05 +0400 Subject: [PATCH 20/28] Update EVM usage example (#1772) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 15e92ad20..2f1cc147d 100644 --- a/README.md +++ b/README.md @@ -138,7 +138,7 @@ contract Adder { """ m = ManticoreEVM() -user_account = m.create_account(balance=1000) +user_account = m.create_account(balance=10000000) contract_account = m.solidity_create_contract(contract_src, owner=user_account, balance=0) From da513511e0c38ef9cb2deb370721cacd47bc9c4a Mon Sep 17 00:00:00 2001 From: feliam Date: Thu, 9 Jul 2020 16:55:38 -0300 Subject: [PATCH 21/28] Add doc, fix output bugs (#1769) * Add doc, fix output bugs * Apply suggestions from code review Co-authored-by: Eric Hennenfent * Readme link Co-authored-by: Eric Hennenfent --- README.md | 9 +- docs/index.rst | 1 + docs/verifier.rst | 172 +++++++++++++++++++++++++++++++++ manticore/ethereum/verifier.py | 7 +- 4 files changed, 185 insertions(+), 4 deletions(-) create mode 100644 docs/verifier.rst diff --git a/README.md b/README.md index 2f1cc147d..1bc5790dd 100644 --- a/README.md +++ b/README.md @@ -78,7 +78,8 @@ Manticore has a command line interface which can perform a basic symbolic analys Analysis results will be placed into a workspace directory beginning with `mcore_`. For information about the workspace, see the [wiki](https://github.com/trailofbits/manticore/wiki/What's-in-the-workspace%3F). #### EVM -Solidity smart contracts must have a `.sol` extension for analysis by Manticore. See a [demo](https://asciinema.org/a/154012). +Manticore CLI automatically detects you are trying to test a contract if (for ex.) + the contract has a `.sol` or a `.vy` extension. See a [demo](https://asciinema.org/a/154012).

Click to expand: @@ -99,6 +100,12 @@ $ manticore examples/evm/umd_example.sol ```
+##### Manticore-verifier + +An alternative CLI tool is provided that simplifys contract testing and +allows writing properties methods in the same high-level language the contract uses. +Checkout manticore-verifier [documentation](http://manticore.readthedocs.io/en/latest/verifier.html). +See a [demo](https://asciinema.org/a/xd0XYe6EqHCibae0RP6c7sJVE) #### Native
diff --git a/docs/index.rst b/docs/index.rst index 049b77883..57bd7e570 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -9,6 +9,7 @@ Manticore is a symbolic execution tool for analysis of binaries and smart contra :maxdepth: 2 :caption: Contents: + verifier base worker states diff --git a/docs/verifier.rst b/docs/verifier.rst new file mode 100644 index 000000000..67e3c7771 --- /dev/null +++ b/docs/verifier.rst @@ -0,0 +1,172 @@ +Property based symbolic executor: manticore-verifier +==================================================== +Manticore installs a separated CLI tool to do property based symbolic execution of smart contracts. :: + + $ manticore-verifier your_contract.sol + +**manticore-verifier** initializes an emulated blockchain environment with a configurable set of +accounts and then sends various symbolic transactions to the target contract containing property methods. +If a way to break a property is found the full transaction trace to reproduce the behaivor is provided. +A configurable stopping condition bounds the exploration, properties not failing are considered to pass. + + +Writing properties in {Solidity/ Vyper} +--------------------------------------- +**manticore-verifier** will detect and test property methods written in the +original contract language. A property can be written in the original language +by simply naming a method in a specific way. For example methods names starting with ```crytic_```. + +.. code-block:: javascript + + function crytic_test_true_property() view public returns (bool){ + return true; + } + +You can select your own way to name property methods using the ``--propre`` commandline argument. :: + + --propre PROPRE A regular expression for selecting properties + +Normal properties +^^^^^^^^^^^^^^^^^ +In the most common case after some precondition is met some logic property must always be true. +Normal properties are property methods that must always return true (or REVERT). + + +Reverting properties +^^^^^^^^^^^^^^^^^^^^ +Sometimes it is difficult to detect that a revert has happened in an internal transaction. +manticore-verifier allows to test for ALWAYS REVERTing property methods. +Revert properties are property methods that must always REVERT. +Reverting property are any property method that contains "revert". For example: + +.. code-block:: javascript + + function crytic_test_must_always_revert() view public returns (bool){ + return true; + } + + +Selecting a target contract +=========================== +**manticore-verifier** needs to be pointed to a the target contract containing any number of property methods. +The target contract is the entry point of the exploration. It needs to initilize any internal structure or external contracts to a correct initial state. All methods of this contract matching the property name criteria will be tested. :: + + --contract_name CONTRACT_NAME The target contract name defined in the source code + + +User accounts +============= +You can specify what are the accounts used in the exploration. +Normaly you do not want the owner or deployer of the contract to send the symbolic transaction and to use a separate unused account to actually check the property methods. +There are 3 types of user accounts: + + - deployer: The account used to create the target contract + - senders: A set of accounts used to send symbolic transactions. Think that these transactions are the ones trying to put the contract in a state that makes the property fail. + - psender: The account used as caller to test the actual property methods + + +You can specify those via command line arguments :: + + --deployer DEPLOYER (optional) address of account used to deploy the contract + --senders SENDERS (optional) a comma separated list of sender addresses. + The properties are going to be tested sending + transactions from these addresses. + --psender PSENDER (optional) address from where the property is tested + + +Or, if you prefer, you can specify a yaml file like this :: + + deployer: "0x41414141414141414141" + sender: ["0x51515151515151515151", "0x52525252525252525252"] + psender: "0x616161616161616161" + +If you specify the accounts both ways the commandline takes precedence over the yaml file. +If you do not provide specific accounts **manticore-verifier** will choose them for you. + + +Stopping condition +================== +The exploration will continue to send symbolic transactions until one of the stopping criteria is met. + +Maximum number of transactions +----------------------------- +You can be interested only in what could happen under a number of transactions. After a maximun number of transactions is reached the explorations ends. Properties that had not be found to be breakable are considered a pass. +You can modify the max number of transactions to test vis a command line argument, otherwise it will stop at 3 transactions. :: + + --maxt MAXT Max transaction count to explore + +Maximun coverage % attained +--------------------------- +By default, if a transaction does not produce new coverage, the exploration is stopped. But you can add a further constraint so that if the provided coverage percentage is obtained, stop. Note that this is the total % of runtime bytecode covered. By default, compilers add dead code, and also in this case the runtime contains the code of the properties methods. So use with care. :: + + --maxcov MAXCOV Stop after maxcov % coverage is obtained in the main + contract + + +Timeout +------- +Exploration will stop after the timeout seconds have pass. :: + + --timeout TIMEOUT Exploration timeout in seconds + + +Walkthrough +----------- +Consider this little contract containing a bug: + +.. code-block:: javascript + + contract Ownership{ // It can have an owner! + address owner = msg.sender; + function Onwer() public{ + owner = msg.sender; + } + modifier isOwner(){ + require(owner == msg.sender); + _; + } + } + contract Pausable is Ownership{ //It is also pausable. You can pause it. You can resume it. + bool is_paused; + modifier ifNotPaused(){ + require(!is_paused); + _; + } + function paused() isOwner public{ + is_paused = true; + } + function resume() isOwner public{ + is_paused = false; + } + } + contract Token is Pausable{ //<< HERE it is. + mapping(address => uint) public balances; // It maintains a balance sheet + function transfer(address to, uint value) ifNotPaused public{ //and can transfer value + balances[msg.sender] -= value; // from one account + balances[to] += value; // to the other + } + } + +Assuming the programmer did not want to allow the magic creation of tokens. +We can design a property around the fact that the initial token count can not be increased over time. Even more relaxed, after the contract creation any account must have less that total count of tokens. The property looks like this : + +.. code-block:: javascript + + contract TestToken is Token{ + constructor() public{ + //here lets initialize the thing + balances[msg.sender] = 10000; //deployer account owns it all! + } + + function crytic_test_balance() view public returns (bool){ + return balances[msg.sender] <= 10000; //nobody can have more than 100% of the tokens + } + + } + +And you can unleash the verifier like this:: + + $manticore-verifier testtoken.sol --contract TestToken + + +f/ diff --git a/manticore/ethereum/verifier.py b/manticore/ethereum/verifier.py index d156ac911..e8ab44d38 100644 --- a/manticore/ethereum/verifier.py +++ b/manticore/ethereum/verifier.py @@ -167,7 +167,7 @@ def manticore_verifier( print(f"# Owner account: 0x{int(owner_account):x}") print(f"# Contract account: 0x{int(contract_account):x}") for n, user_account in enumerate(user_accounts): - print(f"# Sender_{n} account: 0x{int(checker_account):x}") + print(f"# Sender_{n} account: 0x{int(user_account):x}") print(f"# PSender account: 0x{int(checker_account):x}") properties = {} @@ -211,7 +211,7 @@ def manticore_verifier( # check if we sent more than MAXTX transaction if tx_num >= MAXTX: - print("Max numbr of transactions reached({tx_num})") + print(f"Max number of transactions reached ({tx_num})") break tx_num += 1 @@ -219,7 +219,7 @@ def manticore_verifier( new_coverage = m.global_coverage(contract_account) if new_coverage >= MAXCOV: print( - "Current coverage({new_coverage}%) is greater than max allowed({MAXCOV}%).Stopping exploration." + f"Current coverage({new_coverage}%) is greater than max allowed ({MAXCOV}%). Stopping exploration." ) break @@ -484,4 +484,5 @@ def main(): deployer=deployer, psender=psender, timeout=args.timeout, + propre=args.propre, ) From 8a8f35c53d962791a960e88e6f919ef1b03c0e03 Mon Sep 17 00:00:00 2001 From: sschriner <60201678+sschriner@users.noreply.github.com> Date: Tue, 14 Jul 2020 13:17:30 -0400 Subject: [PATCH 22/28] Create a model for strncpy (#1770) * Add strncpy model * Forgot to remove an edit * Adding model tests * Added strncpy c file and created a directory for all string modeling binaries * Update to argument ordering in manticore/native/models.py Co-authored-by: Eric Kilmer * Removed dead code Co-authored-by: Eric Kilmer --- manticore/native/models.py | 57 ++++++++ .../{ => str_model_tests}/sym_strcpy_test | Bin .../{ => str_model_tests}/sym_strcpy_test.c | 0 .../{ => str_model_tests}/sym_strlen_test | Bin .../{ => str_model_tests}/sym_strlen_test.c | 0 .../binaries/str_model_tests/sym_strncpy_test | Bin 0 -> 863992 bytes .../str_model_tests/sym_strncpy_test.c | 14 ++ tests/native/test_models.py | 134 +++++++++++++++++- 8 files changed, 198 insertions(+), 7 deletions(-) rename tests/native/binaries/{ => str_model_tests}/sym_strcpy_test (100%) rename tests/native/binaries/{ => str_model_tests}/sym_strcpy_test.c (100%) rename tests/native/binaries/{ => str_model_tests}/sym_strlen_test (100%) rename tests/native/binaries/{ => str_model_tests}/sym_strlen_test.c (100%) create mode 100755 tests/native/binaries/str_model_tests/sym_strncpy_test create mode 100644 tests/native/binaries/str_model_tests/sym_strncpy_test.c diff --git a/manticore/native/models.py b/manticore/native/models.py index 6f5a67407..cc9c76dcb 100644 --- a/manticore/native/models.py +++ b/manticore/native/models.py @@ -199,6 +199,7 @@ def strlen_approx(state: State, s: Union[int, BitVec]) -> Union[int, BitVec]: Strategy: build a result tree to limit state explosion results approximate Algorithm: Walks from end of string not including NULL building ITE tree when current byte is symbolic. + :param state: current program state :param s: Address of string :return: Symbolic strlen result @@ -268,3 +269,59 @@ def strcpy(state: State, dst: Union[int, BitVec], src: Union[int, BitVec]) -> Un if "strcpy" in state.context: del state.context["strcpy"] return ret + + +def strncpy( + state: State, dst: Union[int, BitVec], src: Union[int, BitVec], n: Union[int, BitVec] +) -> Union[int, BitVec]: + """ + strncpy symbolic model + + Algorithm: Copy n bytes from src to dst. If the length of the src string is less than n pad the difference + with NULL bytes. If a symbolic byte is found that can be NULL but is not definitely NULL fork and concretize states. + + :param state: current program state + :param dst: destination string address + :param src: source string address + :param n: number of bytes to copy + :return: pointer to the dst + """ + + if issymbolic(dst): + raise ConcretizeArgument(state.cpu, 1) + if issymbolic(src): + raise ConcretizeArgument(state.cpu, 2) + if issymbolic(n): + raise ConcretizeArgument(state.cpu, 3) + + cpu = state.cpu + constrs = state.constraints + ret = dst + + # Initialize offset based on whether state has been forked in strncpy + if "strncpy" not in state.context: + offset = 0 + else: + offset = state.context["strncpy"] + + # Copy until a src_byte is symbolic and constrained to '\000', or is concrete and '\000' + src_val = cpu.read_int(src + offset, 8) + while offset < n and not is_definitely_NULL(src_val, constrs): + cpu.write_int(dst + offset, src_val, 8) + + # If a src byte can be NULL concretize and fork states + if can_be_NULL(src_val, constrs): + state.context["strncpy"] = offset + raise Concretize("Forking on NULL strncpy", expression=(src_val == 0), policy="ALL") + offset += 1 + + src_val = cpu.read_int(src + offset, 8) + + # Pad the distance between length of src and n with NULL bytes + while offset < n: + cpu.write_int(dst + offset, 0, 8) + offset += 1 + + if "strncpy" in state.context: + del state.context["strncpy"] + return ret diff --git a/tests/native/binaries/sym_strcpy_test b/tests/native/binaries/str_model_tests/sym_strcpy_test similarity index 100% rename from tests/native/binaries/sym_strcpy_test rename to tests/native/binaries/str_model_tests/sym_strcpy_test diff --git a/tests/native/binaries/sym_strcpy_test.c b/tests/native/binaries/str_model_tests/sym_strcpy_test.c similarity index 100% rename from tests/native/binaries/sym_strcpy_test.c rename to tests/native/binaries/str_model_tests/sym_strcpy_test.c diff --git a/tests/native/binaries/sym_strlen_test b/tests/native/binaries/str_model_tests/sym_strlen_test similarity index 100% rename from tests/native/binaries/sym_strlen_test rename to tests/native/binaries/str_model_tests/sym_strlen_test diff --git a/tests/native/binaries/sym_strlen_test.c b/tests/native/binaries/str_model_tests/sym_strlen_test.c similarity index 100% rename from tests/native/binaries/sym_strlen_test.c rename to tests/native/binaries/str_model_tests/sym_strlen_test.c diff --git a/tests/native/binaries/str_model_tests/sym_strncpy_test b/tests/native/binaries/str_model_tests/sym_strncpy_test new file mode 100755 index 0000000000000000000000000000000000000000..ad8a35f5f6b69c688df0da535935c00d1f85d2df GIT binary patch literal 863992 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%0AY# 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�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�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 Yp) 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

  • &vo_dY$4Eac2hF%}M5b4d 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 +#include +#include +#include +#define LEN 5 + +int main() { + char src[LEN]; + char dst[LEN]; + read(0, src, LEN); + + strncpy(dst, src, LEN - 2); + return 0; +} diff --git a/tests/native/test_models.py b/tests/native/test_models.py index ae718c7f7..a3e5f498c 100644 --- a/tests/native/test_models.py +++ b/tests/native/test_models.py @@ -23,6 +23,7 @@ strlen_exact, strlen_approx, strcpy, + strncpy, is_definitely_NULL, cannot_be_NULL, ) @@ -226,7 +227,9 @@ def test_symbolic_no_fork(self): def test_symbolic_fork(self): # This binary is compiled using gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 # with flags: -g -static -fno-builtin - BIN_PATH = os.path.join(os.path.dirname(__file__), "binaries", "sym_strlen_test") + BIN_PATH = os.path.join( + os.path.dirname(__file__), "binaries/str_model_tests", "sym_strlen_test" + ) tmp_dir = tempfile.TemporaryDirectory(prefix="mcore_test_sym_") m = Manticore(BIN_PATH, stdin_size=10, workspace_url=str(tmp_dir.name)) @@ -294,7 +297,6 @@ def _assert_concrete(self, s, d): dst = cpu.read_int(d, 8) offset = 0 while cannot_be_NULL(src, self.state.constraints): - self.assertTrue(not issymbolic(dst)) self.assertEqual(src, dst) offset += 1 src = cpu.read_int(s + offset, 8) @@ -303,7 +305,6 @@ def _assert_concrete(self, s, d): # Assert final NULL byte self.assertTrue(is_definitely_NULL(src, self.state.constraints)) self.assertEqual(0, dst) - return offset def _test_strcpy(self, string, dst_len=None): """ @@ -312,7 +313,7 @@ def _test_strcpy(self, string, dst_len=None): to dst until the NULL byte, and asserts the memory address returned by strcpy is equal to the given dst address. """ - # Create src and dsty strings + # Create src and dst strings if dst_len is None: dst_len = len(string) cpu = self.state.cpu @@ -330,7 +331,7 @@ def _test_strcpy(self, string, dst_len=None): # addresses should match self.assertEqual(ret, d) # assert everything is copied up to the 1st possible 0 is copied - offset = self._assert_concrete(s, d) + self._assert_concrete(s, d) # Delete stack space created self._pop_string_space(dst_len + len(string)) @@ -348,14 +349,16 @@ def test_concrete_empty(self): def test_symbolic(self): # This binary is compiled using gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 # with flags: -g -static -fno-builtin - BIN_PATH = os.path.join(os.path.dirname(__file__), "binaries", "sym_strcpy_test") + BIN_PATH = os.path.join( + os.path.dirname(__file__), "binaries/str_model_tests", "sym_strcpy_test" + ) tmp_dir = tempfile.TemporaryDirectory(prefix="mcore_test_sym_") m = Manticore(BIN_PATH, stdin_size=10, workspace_url=str(tmp_dir.name)) addr_of_strcpy = 0x400418 @m.hook(addr_of_strcpy) - def strlen_model(state): + def strcpy_model(state): state.invoke_model(strcpy) m.run() @@ -406,3 +409,120 @@ def strlen_model(state): match = True break self.assertTrue(match) + + +class StrncpyTest(ModelTest): + def _assert_concrete(self, s, d, n): + # Checks that n characters are copied until a NULL in the src + # and that NULL is written for the distance between src and NULL + cpu = self.state.cpu + src = cpu.read_int(s, 8) + dst = cpu.read_int(d, 8) + offset = 0 + + # Check that min(n, length of src) characters are copied from src to dst + while not is_definitely_NULL(src, self.state.constraints) and offset < n: + self.assertEqual(src, dst) + offset += 1 + src = cpu.read_int(s + offset, 8) + dst = cpu.read_int(d + offset, 8) + + # Check that N - length of src characters are NULL padded + while offset < n: + self.assertEqual(0, dst) + offset += 1 + dst = cpu.read_int(d + offset, 8) + + def _test_strncpy(self, string, n): + """ + This method creates memory for a given src (with no possible NULL bytes but and a + final NULL byte) and dst string pointers, asserts that everything is copied from src + to dst until the NULL byte, and asserts the memory address returned by strcpy is + equal to the given dst address. + """ + dst_len = n + 1 + cpu = self.state.cpu + s = self._push_string(string) + d = self._push_string_space(dst_len) + dst_vals = [None] * dst_len + for i in range(dst_len): + # Set each dst byte to a random char to simplify equal comparisons + c = random.randrange(1, 255) + cpu.write_int(d + i, c, 8) + dst_vals[i] = c + + ret = strncpy(self.state, d, s, n) + + # addresses should match + self.assertEqual(ret, d) + # assert everything is copied up to the 1st possible 0 is copied + self._assert_concrete(s, d, n) + + # Delete stack space created + self._pop_string_space(dst_len + len(string)) + + def test_concrete(self): + self._test_strncpy("abc\0", n=4) + self._test_strncpy("abcdefghijklm\0", n=20) + self._test_strncpy("a\0", n=10) + + def test_small_n(self): + self._test_strncpy("a\0", n=1) + self._test_strncpy("abcdefghijklm\0", n=0) + + def test_concrete_empty(self): + self._test_strncpy("\0", n=1) + self._test_strncpy("\0", n=10) + + def test_symbolic(self): + # Create src and dst strings + # This binary is compiled using gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 + # with flags: -g -static -fno-builtin + BIN_PATH = os.path.join( + os.path.dirname(__file__), "binaries/str_model_tests", "sym_strncpy_test" + ) + tmp_dir = tempfile.TemporaryDirectory(prefix="mcore_test_sym_") + m = Manticore(BIN_PATH, stdin_size=10, workspace_url=str(tmp_dir.name)) + + addr_of_strncpy = 0x0400490 + + @m.hook(addr_of_strncpy) + def strncpy_model(state): + state.invoke_model(strncpy) + + m.run() + m.finalize() + + # Approximate regexes for expected testcase output + # Example Match above each regex + # Manticore varies the hex output slightly per run + expected = [ + # STDIN: b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + r"STDIN: b\'\\x00(\\x([0-9a-f]{2})){9}\'", + # STDIN: b'\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){1}\\x00(\\x([0-9a-f]{2})){8}\'", + # STDIN: b'\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){2}\\x00(\\x([0-9a-f]{2})){7}\'", + # STDIN: b'\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff' + r"STDIN: b\'(\\x((?!(00))([0-9a-f]{2}))){10}\'", + ] + + inputs = f"{str(m.workspace)}/test_*.input" + + # Make a list of the generated input states + stdins = [] + for inpt in glob(inputs): + with open(inpt) as f: + stdins.append(f.read()) + + # Check the number of input states matches the number of regexes + self.assertEqual(len(stdins), len(expected)) + + # Assert that every regex has a matching input + for e in expected: + match = False + for s in stdins: + if re.fullmatch(e, s) == None: + match = True + break + self.assertTrue(match) From 2159aa76dc15681b758f2990685284f1c61e3b6d Mon Sep 17 00:00:00 2001 From: Eric Hennenfent Date: Tue, 4 Aug 2020 09:17:56 -0700 Subject: [PATCH 23/28] Capture return values in run.sh (#1776) * Capture return value * Increase verifier test timeout * Fix typo * Add more frequent checks to m.is_killed --- manticore/ethereum/verifier.py | 21 ++++++++++++++++++--- scripts/run_tests.sh | 2 ++ tests/ethereum/test_general.py | 1 - 3 files changed, 20 insertions(+), 4 deletions(-) diff --git a/manticore/ethereum/verifier.py b/manticore/ethereum/verifier.py index e8ab44d38..dd9e0b859 100644 --- a/manticore/ethereum/verifier.py +++ b/manticore/ethereum/verifier.py @@ -200,7 +200,7 @@ def manticore_verifier( f"Failing properties: 0/{len(properties)}" ) with m.kill_timeout(timeout=timeout): - while True: + while not m.is_killed(): # check if we found a way to break more than MAXFAIL properties broken_properties = sum(int(len(x) != 0) for x in properties.values()) if broken_properties >= MAXFAIL: @@ -229,7 +229,7 @@ def manticore_verifier( break current_coverage = new_coverage - # check if timeout was requested + # Make sure we didn't time out before starting first transaction if m.is_killed(): print("Cancelled or timeout.") break @@ -256,6 +256,11 @@ def manticore_verifier( data=symbolic_data, ) + # check if timeout was requested during the previous transaction + if m.is_killed(): + print("Cancelled or timeout.") + break + m.clear_terminated_states() # no interest in reverted states m.take_snapshot() # make a copy of all ready states print( @@ -264,6 +269,11 @@ def manticore_verifier( f"Failing properties: {broken_properties}/{len(properties)}" ) + # check if timeout was requested while we were taking the snapshot + if m.is_killed(): + print("Cancelled or timeout.") + break + # And now explore all properties (and only the properties) filter_no_crytic.disable() # Allow crytic_porperties filter_out_human_constants.disable() # Allow them to be marked as constants @@ -315,6 +325,8 @@ def manticore_verifier( m.clear_terminated_states() # no interest in reverted states for now! m.goto_snapshot() + else: + print("Cancelled or timeout.") m.clear_terminated_states() m.clear_ready_states() @@ -410,7 +422,10 @@ def main(): "--psender", type=str, help="(optional) address from where the property is tested" ) eth_flags.add_argument( - "--propre", type=str, help="A regular expression for selecting properties" + "--propre", + default=r"crytic_.*", + type=str, + help="A regular expression for selecting properties", ) eth_flags.add_argument( "--timeout", default=240, type=int, help="Exploration timeout in seconds" diff --git a/scripts/run_tests.sh b/scripts/run_tests.sh index 97b71452f..03aed07bb 100755 --- a/scripts/run_tests.sh +++ b/scripts/run_tests.sh @@ -116,7 +116,9 @@ run_tests_from_dir() { COVERAGE_RCFILE=$GITHUB_WORKSPACE/.coveragerc echo "Running only the tests from 'tests/$DIR' directory" pytest --durations=100 --cov=manticore --cov-config=$GITHUB_WORKSPACE/.coveragerc -n auto "tests/$DIR" + RESULT=$? coverage xml + return $RESULT } run_examples() { diff --git a/tests/ethereum/test_general.py b/tests/ethereum/test_general.py index c09331a76..0aa4bee35 100644 --- a/tests/ethereum/test_general.py +++ b/tests/ethereum/test_general.py @@ -72,7 +72,6 @@ def test_int_ovf(self): class EthVerifierIntegrationTest(unittest.TestCase): def test_propverif(self): smtcfg = config.get_group("smt") - smtcfg.solver = smtcfg.solver.yices with smtcfg.temp_vals(): smtcfg.solver = smtcfg.solver.yices From 547a59c7dbdb68d3ba3a205bd497c45c00305029 Mon Sep 17 00:00:00 2001 From: Eric Kilmer Date: Tue, 4 Aug 2020 18:36:49 -0400 Subject: [PATCH 24/28] Coveralls Take 2 (#1784) * Use coveralls * Use python coveralls * Try again with different casing * Use coveralls repo token from web page * Use GITHUB_TOKEN in github action parallel-finished * Remove codecov config * Add note for final coverage job * Swap Readme coverage badge --- .github/workflows/ci.yml | 24 ++++++++++++++++-------- README.md | 2 +- codecov.yml | 12 ------------ 3 files changed, 17 insertions(+), 21 deletions(-) delete mode 100644 codecov.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7bc009862..ef4a0acef 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -61,6 +61,7 @@ jobs: # Install solc unconditionally because it only takes a second or two sudo wget -O /usr/bin/solc https://github.com/ethereum/solidity/releases/download/v0.4.24/solc-static-linux sudo chmod +x /usr/bin/solc + pip install coveralls pip install -e ".[dev-noks]" - name: Run Tests env: @@ -68,15 +69,22 @@ jobs: run: | cp scripts/run_tests.sh . ./run_tests.sh - - name: Coverage Upload - uses: codecov/codecov-action@v1 + - name: Coveralls Parallel + run: | + coveralls + env: + COVERALLS_PARALLEL: true + COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }} + # Send notification when all tests have finished to combine coverage results + coverage-finish: + needs: tests + runs-on: ubuntu-latest + steps: + - name: Coveralls Finished + uses: coverallsapp/github-action@v1.1.1 with: - token: ${{ secrets.CODECOV_TOKEN }} - file: ./coverage.xml - yml: ./codecov.yml -# Disabled this line because Codecov has been extra flaky lately, and having to re-run the entire -# test suite until every coverage upload step succeeds is more of a hassle than it's worth. -# fail_ci_if_error: true + github-token: ${{ secrets.GITHUB_TOKEN }} + parallel-finished: true upload: runs-on: ubuntu-latest if: github.event_name == 'schedule' diff --git a/README.md b/README.md index 1bc5790dd..0375b0499 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ [![Build Status](https://img.shields.io/github/workflow/status/trailofbits/manticore/CI/master)](https://github.com/trailofbits/manticore/actions?query=workflow%3ACI) -[![Codecov](https://img.shields.io/codecov/c/github/trailofbits/manticore)](https://codecov.io/github/trailofbits/manticore) +[![Coverage Status](https://coveralls.io/repos/github/trailofbits/manticore/badge.svg)](https://coveralls.io/github/trailofbits/manticore) [![PyPI Version](https://badge.fury.io/py/manticore.svg)](https://badge.fury.io/py/manticore) [![Slack Status](https://empireslacking.herokuapp.com/badge.svg)](https://empireslacking.herokuapp.com) [![Documentation Status](https://readthedocs.org/projects/manticore/badge/?version=latest)](http://manticore.readthedocs.io/en/latest/?badge=latest) diff --git a/codecov.yml b/codecov.yml deleted file mode 100644 index bb6dccece..000000000 --- a/codecov.yml +++ /dev/null @@ -1,12 +0,0 @@ -comment: false - -codecov: - notify: - # We have 9 test steps that produce coverage data. - # If we add or remove any, we need to change this number. - after_n_builds: 9 - wait_for_ci: yes - status: - project: - default: - threshold: 0.2% From 2347b21060b897767f86cd7152bff42715e0adba Mon Sep 17 00:00:00 2001 From: feliam Date: Tue, 4 Aug 2020 22:52:16 -0300 Subject: [PATCH 25/28] Change the default to threading (#1779) Co-authored-by: Eric Hennenfent --- manticore/core/manticore.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/manticore/core/manticore.py b/manticore/core/manticore.py index f924008ce..321071c16 100644 --- a/manticore/core/manticore.py +++ b/manticore/core/manticore.py @@ -62,7 +62,7 @@ def to_class(self): ) consts.add("procs", default=10, description="Number of parallel processes to spawn") -proc_type = MProcessingType.multiprocessing +proc_type = MProcessingType.threading if sys.platform != "linux": logger.warning("Manticore is only supported on Linux. Proceed at your own risk!") proc_type = MProcessingType.threading From f20a01143fe01f665f7fad3dba602a6c5db76cbf Mon Sep 17 00:00:00 2001 From: Eric Kilmer Date: Thu, 6 Aug 2020 13:48:56 -0400 Subject: [PATCH 26/28] Use default handler for symbolic system call arguments (#1785) * Use default handler for symbolic system call arguments This will only be called when there is an implementation of the system call in the concrete Linux class and no implementation in the symbolic SLinux. The action is simply to concretize any found symbolic system call arguments. This should hopefully ease the use of Manticore when it encounters symbolic arguments to system calls that don't have specially implemented symbolic handling. A debug message is printed when this happens. * Make sure to return passed implementation * Use rsplit instead of indexing to get owner class of method Co-authored-by: Eric Hennenfent --- manticore/native/cpu/abstractcpu.py | 12 ++++++-- manticore/platforms/linux.py | 47 +++++++++++++++++++++++++++-- tests/native/test_syscalls.py | 27 +++++++++++++++-- 3 files changed, 79 insertions(+), 7 deletions(-) diff --git a/manticore/native/cpu/abstractcpu.py b/manticore/native/cpu/abstractcpu.py index 57489de5c..85e2b3cd5 100644 --- a/manticore/native/cpu/abstractcpu.py +++ b/manticore/native/cpu/abstractcpu.py @@ -3,7 +3,7 @@ import logging import struct import types -from functools import wraps +from functools import wraps, partial from itertools import islice import unicorn @@ -326,6 +326,9 @@ def get_argument_values(self, model: Callable, prefix_args: Tuple) -> Tuple: :param prefix_args: Parameters to pass to model before actual ones :return: Arguments to be passed to the model """ + if type(model) is partial: + # mypy issue with partial types https://github.com/python/mypy/issues/1484 + model = model.args[0] # type: ignore sig = inspect.signature(model) if _sig_is_varargs(sig): model_name = getattr(model, "__qualname__", "") @@ -424,8 +427,13 @@ def invoke(self, model, prefix_args=None): # invoke() will call get_argument_values() self._last_arguments = () - self._cpu._publish("will_execute_syscall", model) + if type(model) is partial: + self._cpu._publish("will_execute_syscall", model.args[0]) + else: + self._cpu._publish("will_execute_syscall", model) ret = super().invoke(model, prefix_args) + if type(model) is partial: + model = model.args[0] self._cpu._publish( "did_execute_syscall", model.__func__.__name__ if isinstance(model, types.MethodType) else model.__name__, diff --git a/manticore/platforms/linux.py b/manticore/platforms/linux.py index bc2e88f01..a8cdf07f8 100644 --- a/manticore/platforms/linux.py +++ b/manticore/platforms/linux.py @@ -10,6 +10,8 @@ import tempfile from abc import ABC, abstractmethod +from functools import partial + from dataclasses import dataclass from itertools import chain @@ -35,8 +37,7 @@ from ..native.state import State from ..platforms.platform import Platform, SyscallNotImplemented, unimplemented -from typing import cast, Any, Deque, Dict, IO, Iterable, List, Optional, Set, Tuple, Union - +from typing import cast, Any, Deque, Dict, IO, Iterable, List, Optional, Set, Tuple, Union, Callable logger = logging.getLogger(__name__) @@ -2577,13 +2578,22 @@ def syscall(self): Syscall dispatcher. """ - index = self._syscall_abi.syscall_number() + index: int = self._syscall_abi.syscall_number() + name: Optional[str] = None try: table = getattr(linux_syscalls, self.current.machine) name = table.get(index, None) if hasattr(self, name): implementation = getattr(self, name) + # If this instance does not have an implementation for the system + # call, but the parent class does, use a partial function to do + # some processing of the unimplemented syscall before using the + # parent's implementation + # '.' is class separator + owner_class = implementation.__qualname__.rsplit(".", 1)[0] + if owner_class != self.__class__.__name__: + implementation = partial(self._handle_unimplemented_syscall, implementation) else: implementation = getattr(self.stubs, name) except (AttributeError, KeyError): @@ -2594,6 +2604,16 @@ def syscall(self): return self._syscall_abi.invoke(implementation) + def _handle_unimplemented_syscall(self, impl: Callable, *args): + """ + Handle an unimplemented system call (for this class) in a generic way + before calling the implementation passed to this function. + + :param impl: The real implementation + :param args: The arguments to the implementation + """ + return impl(*args) + def sys_clock_gettime(self, clock_id, timespec): logger.warning("sys_clock_time not really implemented") if clock_id == 1: @@ -3257,6 +3277,27 @@ def _transform_write_data(self, data: MixedSymbolicBuffer) -> bytes: # Dispatchers... + def _handle_unimplemented_syscall(self, impl: Callable, *args): + """ + Handle all unimplemented syscalls that could have symbolic arguments. + + If a system call has symbolic argument values and there is no + specially implemented function to handle them, then just concretize + all symbolic arguments and call impl with args. + + :param name: Name of the system call + :param args: Arguments for the system call + """ + for i, arg in enumerate(args): + if issymbolic(arg): + logger.debug( + f"Unimplemented symbolic argument to {impl.__name__}. Concretizing argument {i}" + ) + raise ConcretizeArgument(self, i) + + # Call the concrete Linux implementation + return impl(*args) + def sys_exit_group(self, error_code): if issymbolic(error_code): error_code = SelectedSolver.instance().get_value(self.constraints, error_code) diff --git a/tests/native/test_syscalls.py b/tests/native/test_syscalls.py index d5e96091a..343222a04 100644 --- a/tests/native/test_syscalls.py +++ b/tests/native/test_syscalls.py @@ -1,5 +1,4 @@ import logging -import random import struct import socket import tempfile @@ -12,9 +11,10 @@ from glob import glob from manticore.native import Manticore +from manticore.native.cpu.abstractcpu import ConcretizeRegister from manticore.platforms import linux, linux_syscall_stubs -from manticore.platforms.linux import SymbolicSocket +from manticore.platforms.linux import SymbolicSocket, logger as linux_logger from manticore.platforms.platform import SyscallNotImplemented, logger as platform_logger @@ -403,6 +403,29 @@ def test_llseek_end_broken(self): res = self.linux.sys_llseek(fd, 0, -2 * len(buf), resultp, os.SEEK_END) self.assertTrue(res < 0) + def test_unimplemented_symbolic_syscall(self) -> None: + # Load a symbolic argument (address) + cpu = self.linux.current + + # Store the address argument value in RDI + cpu.RDI = self.linux.constraints.new_bitvec(cpu.address_bit_size, "addr") + cpu.RAX = 12 # sys_brk + + # Set logging level to debug so we can match against the message printed + # when executing our catch-all model for # functions with symbolic + # arguments + prev_log_level = linux_logger.getEffectiveLevel() + linux_logger.setLevel(logging.DEBUG) + + with self.assertLogs(linux_logger, logging.DEBUG) as cm: + with self.assertRaises(ConcretizeRegister): + # Call the system call number in RAX + self.linux.syscall() + dmsg = "Unimplemented symbolic argument to sys_brk. Concretizing argument 0" + self.assertIn(dmsg, "\n".join(cm.output)) + + linux_logger.setLevel(prev_log_level) + def test_unimplemented_stubs(self) -> None: stubs = linux_syscall_stubs.SyscallStubs(default_to_fail=False) From 9b2c2f29c9e722152707ce8eb7f4443fc3e3ee28 Mon Sep 17 00:00:00 2001 From: Eric Kilmer Date: Tue, 11 Aug 2020 13:40:15 -0400 Subject: [PATCH 27/28] Linux: Add stat method for FdLike (#1780) * Linux: Add stat method for FdLike * Add tests * Don't try to cover abstract class function bodies * Update test file names * Try again to not cover abstract methods * Add typehint to Directory stat() Co-authored-by: Eric Hennenfent * Fix typehints with os.stat * Adjust type for stat object Co-authored-by: Eric Hennenfent --- .coveragerc | 8 ++ manticore/platforms/linux.py | 92 +++++++++++++----- tests/native/test_syscalls.py | 174 ++++++++++++++++++++++++++++++++++ 3 files changed, 248 insertions(+), 26 deletions(-) diff --git a/.coveragerc b/.coveragerc index 37058bd54..a57809fa1 100644 --- a/.coveragerc +++ b/.coveragerc @@ -2,3 +2,11 @@ source = manticore omit = *__init__.py + +[report] +exclude_lines = + # Have to re-enable the standard pragma + pragma: no cover + + # Don't try to cover special syntax "..." in abstract class + @abstractmethod diff --git a/manticore/platforms/linux.py b/manticore/platforms/linux.py index a8cdf07f8..9e8ccc48d 100644 --- a/manticore/platforms/linux.py +++ b/manticore/platforms/linux.py @@ -106,6 +106,48 @@ class creation time, you will get an error only if you try to instantiate return cls +@dataclass +class StatResult: + """ + Data structure corresponding to result received from stat, fstat, lstat for + information about a file. + + See https://man7.org/linux/man-pages/man2/stat.2.html for more info + """ + + st_mode: int + st_ino: int + st_dev: int + st_nlink: int + st_uid: int + st_gid: int + st_size: int + st_atime: float + st_mtime: float + st_ctime: float + st_blksize: int + st_blocks: int + st_rdev: int + + +def convert_os_stat(stat: os.stat_result) -> StatResult: + return StatResult( + st_mode=stat.st_mode, + st_ino=stat.st_ino, + st_dev=stat.st_dev, + st_nlink=stat.st_nlink, + st_uid=stat.st_uid, + st_gid=stat.st_gid, + st_size=stat.st_size, + st_atime=stat.st_atime, + st_mtime=stat.st_mtime, + st_ctime=stat.st_ctime, + st_blksize=stat.st_blksize, + st_blocks=stat.st_blocks, + st_rdev=stat.st_rdev, + ) + + class FdLike(ABC): """ An abstract class for different kinds of file descriptors. @@ -143,6 +185,10 @@ def ioctl(self, request, argp) -> int: def tell(self) -> int: ... + @abstractmethod + def stat(self) -> StatResult: + ... + @dataclass class FdTableEntry: @@ -276,11 +322,11 @@ def mode(self) -> str: def closed(self) -> bool: return self.file.closed - def stat(self): + def stat(self) -> StatResult: try: - return os.fstat(self.fileno()) + return convert_os_stat(os.stat(self.fileno())) except OSError as e: - return -e.errno + raise FdError(f"Cannot stat: {e.strerror}", e.errno) def ioctl(self, request, argp): try: @@ -376,6 +422,12 @@ def close(self): except OSError as e: return -e.errno + def stat(self) -> StatResult: + try: + return convert_os_stat(os.stat(self.fileno())) + except OSError as e: + raise FdError(f"Cannot stat: {e.strerror}", e.errno) + def fileno(self): return self.fd @@ -542,31 +594,17 @@ def ioctl(self, request, argp): def tell(self) -> int: raise FdError("Invalid tell() operation on SocketDesc", errno.EBADF) + def stat(self) -> StatResult: + # Copied from Socket.stat + return StatResult( + 8592, 11, 9, 1, 1000, 5, 0, 1378673920, 1378673920, 1378653796, 0x400, 0x8808, 0 + ) + @concreteclass class Socket(FdLike): def stat(self): - from collections import namedtuple - - stat_result = namedtuple( - "stat_result", - [ - "st_mode", - "st_ino", - "st_dev", - "st_nlink", - "st_uid", - "st_gid", - "st_size", - "st_atime", - "st_mtime", - "st_ctime", - "st_blksize", - "st_blocks", - "st_rdev", - ], - ) - return stat_result( + return StatResult( 8592, 11, 9, 1, 1000, 5, 0, 1378673920, 1378673920, 1378653796, 0x400, 0x8808, 0 ) @@ -3071,8 +3109,10 @@ def sys_getdents(self, fd, dirent, count) -> int: # Don't overflow buffer break - stat = item.stat() - print(f"FILE MODE: {item.name} :: {stat.st_mode:o}") + try: + stat = item.stat() + except FdError as e: + return -e.err # https://elixir.bootlin.com/linux/v5.1.15/source/include/linux/fs_types.h#L27 d_type = (stat.st_mode >> 12) & 15 diff --git a/tests/native/test_syscalls.py b/tests/native/test_syscalls.py index 343222a04..d93633add 100644 --- a/tests/native/test_syscalls.py +++ b/tests/native/test_syscalls.py @@ -91,6 +91,180 @@ def test_directories(self): self.linux.sys_rmdir(0x1100) self.assertFalse(os.path.exists(dname)) + def test_dir_stat(self): + dname = self.get_path("test_dir_stat") + self.assertFalse(os.path.exists(dname)) + + self.linux.current.memory.mmap(0x1000, 0x1000, "rw") + self.linux.current.write_string(0x1100, dname) + + # Create it as a dir + self.linux.sys_mkdir(0x1100, mode=0o777) + fd = self.linux.sys_open(0x1100, flags=os.O_RDONLY | os.O_DIRECTORY, mode=0o777) + self.assertTrue(os.path.exists(dname)) + self.assertGreater(fd, 0) + + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Remove from file system on host but not in Manticore + os.rmdir(dname) + self.assertFalse(os.path.exists(dname)) + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertLess(res, 0) + # The file descriptor is still valid even though the directory is gone + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Remove the directory using Manticore + self.linux.sys_rmdir(0x1100) + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertLess(res, 0) + # The file descriptor is still valid even though the directory is gone + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Close the file descriptor to totally remove it + self.linux.sys_close(fd) + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertLess(res, 0) + + def test_file_stat(self): + fname = self.get_path("test_file_stat") + self.assertFalse(os.path.exists(fname)) + + self.linux.current.memory.mmap(0x1000, 0x1000, "rw") + self.linux.current.write_string(0x1100, fname) + + # Create a file + fd = self.linux.sys_open(0x1100, os.O_RDWR, 0o777) + self.assertTrue(os.path.exists(fname)) + + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Remove from file system on host but not in Manticore + os.remove(fname) + self.assertFalse(os.path.exists(fname)) + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Remove the file using Manticore + self.linux.sys_unlink(0x1100) + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Close the file descriptor to totally remove it + self.linux.sys_close(fd) + res = self.linux.sys_stat32(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_stat64(0x1100, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertLess(res, 0) + + def test_socketdesc_stat(self): + self.linux.current.memory.mmap(0x1000, 0x1000, "rw") + + # Create a socket + fd = self.linux.sys_socket(socket.AF_INET, socket.SOCK_STREAM, 0) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertEqual(res, 0) + + # Close the socket + self.linux.sys_close(fd) + res = self.linux.sys_newfstat(fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat(fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat64(fd, 0x1200) + self.assertLess(res, 0) + + def test_socket_stat(self): + self.linux.current.memory.mmap(0x1000, 0x1000, "rw") + + # Create a socket + sock_fd = self.linux.sys_socket(socket.AF_INET, socket.SOCK_STREAM, 0) + self.linux.sys_bind(sock_fd, None, None) + self.linux.sys_listen(sock_fd, None) + conn_fd = self.linux.sys_accept(sock_fd, None, 0) + + res = self.linux.sys_newfstat(conn_fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat(conn_fd, 0x1200) + self.assertEqual(res, 0) + res = self.linux.sys_fstat64(conn_fd, 0x1200) + self.assertEqual(res, 0) + + # Close the socket + self.linux.sys_close(conn_fd) + res = self.linux.sys_newfstat(conn_fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat(conn_fd, 0x1200) + self.assertLess(res, 0) + res = self.linux.sys_fstat64(conn_fd, 0x1200) + self.assertLess(res, 0) + def test_pipe(self): self.linux.current.memory.mmap(0x1000, 0x1000, "rw") self.linux.sys_pipe(0x1100) From 4334d89354be228e0cdf6d133e0ad4730dd55ba4 Mon Sep 17 00:00:00 2001 From: Eric Kilmer Date: Tue, 11 Aug 2020 21:21:35 -0400 Subject: [PATCH 28/28] Add Manticore native State-specific hooks (#1777) * Add Manticore native State-specific hooks * Add tests * Add type hints when setting state * Add back needed assertion for PC hook * Test that hook actually executes in test Co-authored-by: Eric Hennenfent --- manticore/native/manticore.py | 23 ++++-- manticore/native/state.py | 136 +++++++++++++++++++++++++++++++++- tests/native/test_state.py | 109 +++++++++++++++++++++++++++ 3 files changed, 261 insertions(+), 7 deletions(-) diff --git a/manticore/native/manticore.py b/manticore/native/manticore.py index 95827b706..0d6620409 100644 --- a/manticore/native/manticore.py +++ b/manticore/native/manticore.py @@ -5,11 +5,12 @@ import os import shlex import time +from typing import Callable, Optional import sys from elftools.elf.elffile import ELFFile from elftools.elf.sections import SymbolTableSection -from .state import State +from .state import HookCallback, State from ..core.manticore import ManticoreBase from ..core.smtlib import ConstraintSet from ..core.smtlib.solver import SelectedSolver, issymbolic @@ -229,19 +230,28 @@ def decorator(f): return decorator - def add_hook(self, pc, callback, after=False): + def add_hook( + self, + pc: Optional[int], + callback: HookCallback, + after: bool = False, + state: Optional[State] = None, + ): """ Add a callback to be invoked on executing a program counter. Pass `None` for pc to invoke callback on every instruction. `callback` should be a callable that takes one :class:`~manticore.core.state.State` argument. :param pc: Address of instruction to hook - :type pc: int or None - :param callable callback: Hook function + :param callback: Hook function + :param after: Hook after PC executes? + :param state: Optionally, add hook for this state only, else all states """ if not (isinstance(pc, int) or pc is None): raise TypeError(f"pc must be either an int or None, not {pc.__class__.__name__}") - else: + + if state is None: + # add hook to all states hooks, when, hook_callback = ( (self._hooks, "will_execute_instruction", self._hook_callback) if not after @@ -250,6 +260,9 @@ def add_hook(self, pc, callback, after=False): hooks.setdefault(pc, set()).add(callback) if hooks: self.subscribe(when, hook_callback) + else: + # only hook for the specified state + state.add_hook(pc, callback, after) def _hook_callback(self, state, pc, instruction): "Invoke all registered generic hooks" diff --git a/manticore/native/state.py b/manticore/native/state.py index da0f6930b..7dd0289f0 100644 --- a/manticore/native/state.py +++ b/manticore/native/state.py @@ -1,8 +1,15 @@ +import copy from collections import namedtuple -from typing import Any, NamedTuple +from typing import Any, Callable, Dict, NamedTuple, Optional, Set, Tuple, Union +from .cpu.disasm import Instruction +from .memory import ConcretizeMemory, MemoryException +from .. import issymbolic from ..core.state import StateBase, Concretize, TerminateState -from ..native.memory import ConcretizeMemory, MemoryException +from ..core.smtlib import Expression + + +HookCallback = Callable[[StateBase], None] class CheckpointData(NamedTuple): @@ -11,6 +18,131 @@ class CheckpointData(NamedTuple): class State(StateBase): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._hooks: Dict[Optional[int], Set[HookCallback]] = {} + self._after_hooks: Dict[Optional[int], Set[HookCallback]] = {} + + def __getstate__(self) -> Dict[str, Any]: + state = super().__getstate__() + state["hooks"] = self._hooks + state["after_hooks"] = self._after_hooks + return state + + def __setstate__(self, state: Dict[str, Any]) -> None: + super().__setstate__(state) + self._hooks = state["hooks"] + self._after_hooks = state["after_hooks"] + self._resub_hooks() + + def __enter__(self) -> "State": + new_state = super().__enter__() + new_state._hooks = copy.copy(self._hooks) + new_state._after_hooks = copy.copy(self._after_hooks) + return new_state + + def _get_hook_context( + self, after: bool = True + ) -> Tuple[Dict[Optional[int], Set[HookCallback]], str, Any]: + """ + Internal helper function to get hook context information. + + :param after: Whether we want info pertaining to hooks after instruction executes or before + :return: Information for hooks after or before: + - set of hooks for specified after or before + - string of callback event + - State function that handles the callback + """ + return ( + (self._hooks, "will_execute_instruction", self._state_hook_callback) + if not after + else (self._after_hooks, "did_execute_instruction", self._state_after_hook_callback) + ) + + def remove_hook(self, pc: Optional[int], callback: HookCallback, after: bool = False) -> bool: + """ + Remove a callback with the specified properties + :param pc: Address of instruction to remove from + :param callback: The callback function that was at the address + :param after: Whether it was after instruction executed or not + :return: Whether it was removed + """ + hooks, when, _ = self._get_hook_context(after) + cbs = hooks.get(pc, set()) + if callback in cbs: + cbs.remove(callback) + else: + return False + + if len(hooks.get(pc, set())) == 0: + del hooks[pc] + + return True + + def add_hook(self, pc: Optional[int], callback: HookCallback, after: bool = False) -> None: + """ + Add a callback to be invoked on executing a program counter. Pass `None` + for pc to invoke callback on every instruction. `callback` should be a callable + that takes one :class:`~manticore.native.state.State` argument. + + :param pc: Address of instruction to hook + :param callback: Hook function + :param after: Hook after PC executes? + :param state: Add hook to this state + """ + hooks, when, hook_callback = self._get_hook_context(after) + hooks.setdefault(pc, set()).add(callback) + if hooks: + self.subscribe(when, hook_callback) + + def _resub_hooks(self) -> None: + """ + Internal helper function to resubscribe hook callback events when the + state is active again. + """ + # TODO: check if the lists actually have hooks + _, when, hook_callback = self._get_hook_context(False) + self.subscribe(when, hook_callback) + + _, when, hook_callback = self._get_hook_context(True) + self.subscribe(when, hook_callback) + + def _state_hook_callback(self, pc: int, _instruction: Instruction) -> None: + """ + Invoke all registered State hooks before the instruction executes. + + :param pc: Address where the hook should run + :param _instruction: Instruction at this PC + """ + # Prevent crash if removing hook(s) during a callback + tmp_hooks = copy.deepcopy(self._hooks) + + # Invoke all pc-specific hooks + for cb in tmp_hooks.get(pc, []): + cb(self) + + # Invoke all pc-agnostic hooks + for cb in tmp_hooks.get(None, []): + cb(self) + + def _state_after_hook_callback(self, last_pc: int, _pc: int, _instruction: Instruction): + """ + Invoke all registered State hooks after the instruction executes. + + :param last_pc: Address where the hook should run after instruction execution + :param _pc: Next address to execute + :param _instruction: Instruction at this last_pc + """ + # Prevent crash if removing hook(s) during a callback + tmp_hooks = copy.deepcopy(self._after_hooks) + # Invoke all pc-specific hooks + for cb in tmp_hooks.get(last_pc, []): + cb(self) + + # Invoke all pc-agnostic hooks + for cb in tmp_hooks.get(None, []): + cb(self) + @property def cpu(self): """ diff --git a/tests/native/test_state.py b/tests/native/test_state.py index ac7df6e09..93597ec2d 100644 --- a/tests/native/test_state.py +++ b/tests/native/test_state.py @@ -1,6 +1,9 @@ +import io import unittest import os +from contextlib import redirect_stdout +from manticore.core.state import StateBase from manticore.utils.event import Eventful from manticore.platforms import linux from manticore.native.state import State @@ -157,6 +160,63 @@ def test_tainted_symbolic_value(self): expr = self.state.new_symbolic_value(64, taint=taint) self.assertEqual(expr.taint, frozenset(taint)) + def test_state_hook(self): + initial_state = State(ConstraintSet(), FakePlatform()) + + def fake_hook(_: StateBase) -> None: + return None + + self.assertTrue(len(initial_state._hooks) == 0) + self.assertTrue(len(initial_state._after_hooks) == 0) + + # This hook should be propagated to child state + initial_state.add_hook(0x4000, fake_hook, after=False) + + self.assertTrue(len(initial_state._hooks) == 1) + self.assertTrue(len(initial_state._after_hooks) == 0) + + with initial_state as new_state: + # Child state has parent's hook + self.assertTrue(len(new_state._hooks) == 1) + self.assertTrue(len(new_state._after_hooks) == 0) + + # Try adding the same hook + new_state.add_hook(0x4000, fake_hook, after=False) + # Should not add again + self.assertTrue(len(new_state._hooks) == 1) + + # Add two hooks for after and before instruction + new_state.add_hook(0x4001, fake_hook, after=True) + new_state.add_hook(0x4001, fake_hook, after=False) + + # A new hook added to both lists + self.assertTrue(len(new_state._hooks) == 2) + self.assertTrue(len(new_state._after_hooks) == 1) + + # Ensure parent state was not affected + self.assertTrue(len(initial_state._hooks) == 1) + self.assertTrue(len(initial_state._after_hooks) == 0) + + # Remove one of the hooks we added + new_state.remove_hook(0x4000, fake_hook, after=False) + # Try to remove a non-existent hook + self.assertFalse(new_state.remove_hook(0x4000, fake_hook, after=True)) + + # Ensure removal + self.assertTrue(len(new_state._hooks) == 1) + self.assertTrue(len(new_state._after_hooks) == 1) + + # Ensure parent state wasn't affected + self.assertTrue(len(initial_state._hooks) == 1) + self.assertTrue(len(initial_state._after_hooks) == 0) + + # Add hook to all PC in our parent state + initial_state.add_hook(None, fake_hook, after=True) + + # Ensure only the hooks we added are still here + self.assertTrue(len(initial_state._hooks) == 1) + self.assertTrue(len(initial_state._after_hooks) == 1) + def testContextSerialization(self): import pickle as pickle @@ -211,6 +271,55 @@ def testContextSerialization(self): self.assertEqual(new_new_state.context["step"], 30) +""" +This function needs to be a global function for the following test or else we +get the following error + E AttributeError: Can't pickle local object 'StateHooks.test_state_hooks..do_nothing' +""" + + +def do_nothing(_: StateBase) -> None: + return None + + +def fin(_: StateBase) -> None: + print("Reached fin callback") + return None + + +class StateHooks(unittest.TestCase): + def setUp(self): + core = config.get_group("core") + core.seed = 61 + core.mprocessing = core.mprocessing.single + + dirname = os.path.dirname(__file__) + self.m = Manticore(os.path.join(dirname, "binaries", "basic_linux_amd64"), policy="random") + + def test_state_hooks(self): + @self.m.hook(0x400610, after=True) + def process_hook(state: State) -> None: + # We can't remove because the globally applied hooks are stored in + # the Manticore class, not State + self.assertFalse(state.remove_hook(0x400610, process_hook, after=True)) + # We can remove this one because it was applied specifically to this + # State (or its parent) + self.assertTrue(state.remove_hook(None, do_nothing, after=True)) + + state.add_hook(None, do_nothing, after=False) + state.add_hook(None, do_nothing, after=True) + state.add_hook(0x400647, fin, after=True) + state.add_hook(0x400647, fin, after=False) + + for state in self.m.ready_states: + self.m.add_hook(None, do_nothing, after=True, state=state) + + f = io.StringIO() + with redirect_stdout(f): + self.m.run() + self.assertIn("Reached fin callback", f.getvalue()) + + class StateMergeTest(unittest.TestCase): # Need to add a plugin that counts the number of states in did_fork_state, and records the max

    • K1H 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