<carver, Jason Carver> You mean you want to run a series of transactions on mainnet state, right? AIUI this feature supports it: https://eth-brownie.readthedocs.io/en/stable/network-management.html#using-a-forked-development-network
hello, whenever i run the tests the output shows that spaces and tabs are mixed. Could that prevent the scripts from running or the tests from succeeding? The part of the output that lets me know this is not displayed as an error, so I'm assuming the answer is no, but is that so?
oh and I also get
ERROR: InvocationError for command /usr/bin/make validate-docs and the docs failing. No idea why
<Christoph Burgdorf (cburgdorf)> I would recommend that you base your work on #1933 and then rebase everything (the combination of 1933 + your commits) on top of master. That way, you have all the pre-existing Berlin work while at the same time keeping things up to date with master
after having installed, I get weird errors when running tests, such as
from hypothesis import (
E ModuleNotFoundError: No module named 'hypothesis' when running pytest database
I'm looking into the possibility of building a plugin for py-evm that would give more control over calling individual opcodes and logging. This is for optimizing close to metal methods (curve / cryptography). Part of this is in developing custom op-codes and interfacing them with the greater py-evm, and then being able to call them arbitrarily. Can I just use an instance of BaseComputation and overwrite as many builtin opcodes / custom opcodes as I feel like? If so, is there an example of this being done?
So I got a prototype of what I mean working, is there a better way to do this? https://github.com/alita-moore/BLS12-381-Huff/blob/1f5baa0d576d7dc0a240d6f8ea99d6c3fc06d13e/src/scratch.py#L1
Hey @alita-moore. This test file has some great examples for your use case:
https://github.com/ethereum/py-evm/blob/master/tests/core/opcodes/test_opcodes.py
https://github.com/ethereum/py-evm/blob/master/tests/core/opcodes/test_opcodes.py
I converted your code to use utilities from test_opcodes.py
from eth.vm.forks import (
IstanbulVM,
)
from eth.vm import (
opcode_values
)
from tests.core.opcodes.test_opcodes import (
assemble,
CANONICAL_ADDRESS_B,
setup_computation,
)
code = assemble(
opcode_values.PUSH1,
0x1,
opcode_values.PUSH1,
0x1,
opcode_values.ADD
)
computation = setup_computation(IstanbulVM, CANONICAL_ADDRESS_B, code)
comp = computation.apply_message(
computation.state,
computation.msg,
computation.transaction_context,
)
result = comp.stack_pop1_any()
print(result)
and here’s how you can add an opcode:
import copy
from typing import (
Type,
)
from eth_utils.toolz import merge
from eth import constants
from eth.vm.computation import BaseComputation
from eth.vm.forks.istanbul import IstanbulVM
from eth.vm.forks.istanbul.computation import IstanbulComputation
from eth.vm.forks.istanbul.opcodes import ISTANBUL_OPCODES
from eth.vm.forks.istanbul.state import IstanbulState
from eth.vm.opcode import as_opcode
from eth.vm.state import BaseState
SUBTRACT_OPCODE_VALUE = 0xa5
SUBTRACT_MNEMONIC = 'SUBTRACT'
def sub(computation: BaseComputation) -> None:
left, right = computation.stack_pop_ints(2)
result = (left - right) & constants.UINT_256_MAX
computation.stack_push_int(result)
UPDATED_OPCODES = {
SUBTRACT_OPCODE_VALUE: as_opcode(
logic_fn=sub,
mnemonic=SUBTRACT_MNEMONIC,
gas_cost=constants.GAS_LOW,
)
}
CUSTOM_OPCODES = merge(
copy.deepcopy(ISTANBUL_OPCODES),
UPDATED_OPCODES,
)
class CustomComputation(IstanbulComputation):
opcodes = CUSTOM_OPCODES
class CustomState(IstanbulState):
computation_class = CustomComputation
class CustomVm(IstanbulVM):
_state_class: Type[BaseState] = CustomState# ... your code
def gen_context(VM):
CANONICAL_ADDRESS_A = to_canonical_address("0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6")
CANONICAL_ADDRESS_B = to_canonical_address("0xcd1722f3947def4cf144679da39c4c32bdc35681")
state = VM.state
message = Message(
to=CANONICAL_ADDRESS_A,
sender=CANONICAL_ADDRESS_B,
create_address=None,
value=0,
data=b'',
code=b'',
gas=1000000,
)
tx_context = VM._state_class.transaction_context_class(gas_price=1, origin=CANONICAL_ADDRESS_B)
return state, message, tx_context
#########################
VM = CustomVM()
state, message, tx = gen_context(VM)
computation = VM._state_class.computation_class(state, message, tx)
computation.stack_push_int(1)
computation.stack_push_int(1)
computation.opcodes["SUBTRACT"](computation)
result = computation.stack_pop1_int()
also what's the best way to get debug-level information about the exact bytes in the stack / memory?
How about this:
code = assemble(
opcode_values.PUSH1,
0x1,
opcode_values.PUSH1,
0x1,
SUBTRACT_OPCODE_VALUE
)
computation = setup_computation(CustomVm, CANONICAL_ADDRESS_B, code)
comp = computation.apply_message(
computation.state,
computation.msg,
computation.transaction_context,
)
result = comp.stack_pop1_any()
print(result)from tests.core.opcodes.test_opcodes import setup_computation
(i don't intend on doing anything above opcode / memory level)
also what’s the best way to get debug-level information about the exact bytes in the stack / memory?
You can take inspiration from this project: https://github.com/status-im/vyper-debug. Although it only works for vyper.
@alita-moore A project I’d suggest looking at is eth-brownie. It has a pretty good debug API.
https://eth-brownie.readthedocs.io/en/stable/core-transactions.html#call-traces
https://eth-brownie.readthedocs.io/en/stable/core-transactions.html#call-traces
thanks
<carver, Jason Carver> @alita-moore
do you think computation will always have a _stack option?