Adds a dictionary of event args/data to Event type for easier access to variables

boa/environment.py

@@ -572,7 +572,7 @@ def _hook_trace_computation(self, computation, contract=None):
             # loop over pc so that it is available when coverage hooks into it
             pass
         for child in computation.children:
-            if child.msg.code_address != b'':
+            if child.msg.code_address != b"":
                 child_contract = self.lookup_contract(child.msg.code_address)
                 self._hook_trace_computation(child, child_contract)
 

boa/vyper/contract.py

@@ -653,7 +653,6 @@ def decode_log(self, e):
             )
 
         tuple_typ = TupleT(arg_typs)
-
         args = abi.decode(tuple_typ.abi_type.selector_name(), data)
 
         return Event(log_id, self.address, event_t, decoded_topics, args)

boa/vyper/event.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
-from typing import Any, List
+from functools import cached_property
+from typing import Any, Dict, List, Tuple
 
 
 @dataclass
@@ -11,6 +12,14 @@ class Event:
     args: List[Any]  # list of decoded args
 
     def __repr__(self):
+        args = ", ".join(f"{k}={v}" for k, v in self.ordered_args())
+        return f"{self.event_type.name}({args})"
+
+    @cached_property
+    def args_map(self) -> Dict[str, str | int]:
+        return dict(self.ordered_args())
+
+    def ordered_args(self) -> List[Tuple[str, str | int]]:
         t_i = 0
         a_i = 0
         b = []
@@ -26,8 +35,7 @@ def __repr__(self):
                 b.append((k, self.args[a_i]))
                 a_i += 1
 
-        args = ", ".join(f"{k}={v}" for k, v in b)
-        return f"{self.event_type.name}({args})"
+        return b
 
 
 class RawEvent:

tests/unitary/test/stateful/test_state_machine_isolation.py → tests/unitary/stateful/test_state_machine_isolation.py

@@ -1,3 +1,4 @@
+import hypothesis.strategies as st
 import pytest
 from hypothesis._settings import HealthCheck
 from hypothesis.stateful import (
@@ -17,27 +18,30 @@ def boa_contract():
 a: public(uint256)
 
 @external
-def add_to_a(_a: uint256):
-    self.a += _a
+def add_to_a(d: uint256):
+    self.a += d
 """
     return boa.loads(source_code)
 
 
+NUM_STEPS = 100
+
+
 class StateMachine(RuleBasedStateMachine):
     contract = None
 
     @initialize()
     def setup(self):
-        self.contract.add_to_a(10)
+        self.a = 0
 
-    # empty rule just so hypothesis does not complain
-    @rule()
-    def void(self):
-        pass
+    @rule(d=st.integers(min_value=0, max_value=(2**256) // NUM_STEPS))
+    def change_a(self, d):
+        self.contract.add_to_a(d)
+        self.a += d
 
     @invariant()
     def foo(self):
-        assert self.contract.a() == 10
+        assert self.contract.a() == self.a
 
     # ensure overriding teardown doesn't break things
     def teardown(self):
@@ -47,7 +51,7 @@ def teardown(self):
 def test_state_machine_isolation(boa_contract):
     StateMachine.contract = boa_contract
     StateMachine.settings = {
-        "max_examples": 5,
+        "stateful_step_count": NUM_STEPS,
         "suppress_health_check": HealthCheck.all(),
     }
     run_state_machine_as_test(StateMachine)

tests/unitary/test_event.py

@@ -0,0 +1,44 @@
+from boa.interpret import load
+
+me = "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"
+token = load("examples/ERC20.vy", "Test", "TEST", 18, 0)
+token.mint(me, 100)
+event = token.get_logs()[0]
+
+
+def test_topics_saved_to_event():
+    assert len(event.topics) == 2
+    assert event.topics[0] == "0x0000000000000000000000000000000000000000"
+    assert event.topics[1] == me
+
+
+def test_args_saved_to_event():
+    assert len(event.args) == 1
+    assert event.args[0] == 100
+
+
+def test_args_ordered_to_event_param_sequence():
+    args = event.ordered_args()
+    assert args[0][0] == "sender"
+    assert args[1][0] == "receiver"
+    assert args[2][0] == "value"
+
+
+def test_args_map_match_event_params():
+    args = event.args_map
+    assert args["sender"] == "0x0000000000000000000000000000000000000000"
+    assert args["receiver"] == me
+    assert args["value"] == 100
+
+
+def test_args_map_values_match_ordered_args():
+    assert event.args_map == {
+        "sender": "0x0000000000000000000000000000000000000000",
+        "receiver": me,
+        "value": 100,
+    }
+    assert event.ordered_args() == [
+        ("sender", "0x0000000000000000000000000000000000000000"),
+        ("receiver", me),
+        ("value", 100),
+    ]