fix: guard against mutating code in non-mutable functions

tests/parser/exceptions/test_constancy_exception.py

@@ -76,16 +76,111 @@ def foo():
     for i in range(x):
         pass""",
         """
-f:int128
+from vyper.interfaces import ERC20
+
+token: ERC20
 
 @external
-def a (x:int128):
-    self.f = 100
+@view
+def topup(amount: uint256):
+    assert self.token.transferFrom(msg.sender, self, amount)
+        """,
+        """
+from vyper.interfaces import ERC20
 
+token: ERC20
+
+@external
 @view
+def topup(amount: uint256):
+    x: bool = self.token.transferFrom(msg.sender, self, amount)
+        """,
+        """
+from vyper.interfaces import ERC20
+
+token: ERC20
+
 @external
-def b():
-    self.a(10)""",
+@view
+def topup(amount: uint256):
+    x: bool = False
+    x = self.token.transferFrom(msg.sender, self, amount)
+        """,
+        """
+from vyper.interfaces import ERC20
+
+token: ERC20
+
+@external
+@view
+def topup(amount: uint256) -> bool:
+    return self.token.transferFrom(msg.sender, self, amount)
+        """,
+        """
+a: DynArray[uint256, 3]
+
+@external
+@view
+def foo():
+    assert self.a.pop() > 123, "vyper"
+        """,
+        """
+a: DynArray[uint256, 3]
+
+@external
+@view
+def foo():
+    x: uint256 = self.a.pop()
+        """,
+        """
+a: DynArray[uint256, 3]
+
+@external
+@view
+def foo():
+    x: uint256 = 0
+    x = self.a.pop()
+        """,
+        """
+a: DynArray[uint256, 3]
+
+@external
+@view
+def foo() -> uint256:
+    return self.a.pop()
+        """,
+        """
+@external
+@view
+def foo(x: address):
+    assert convert(
+        raw_call(
+            x,
+            b'',
+            max_outsize=32,
+            revert_on_failure=False
+        ), uint256
+    ) > 123, "vyper"
+        """,
+        """
+@external
+@view
+def foo(a: address):
+    x: address = create_minimal_proxy_to(a)
+        """,
+        """
+@external
+@view
+def foo(a: address):
+    x: address = empty(address)
+    x = create_copy_of(a)
+        """,
+        """
+@external
+@view
+def foo(a: address) -> address:
+    return create_from_blueprint(a)
+        """,
     ],
 )
 def test_statefulness_violations(bad_code):

tests/parser/features/decorators/test_view.py

@@ -1,3 +1,5 @@
+import pytest
+
 from vyper.exceptions import FunctionDeclarationException
 
 
@@ -28,3 +30,25 @@ def foo() -> num:
     assert_compile_failed(
         lambda: get_contract_with_gas_estimation_for_constants(code), FunctionDeclarationException
     )
+
+
+good_code = [
+    """
+@external
+@view
+def foo(x: address):
+    assert convert(
+        raw_call(
+            x,
+            b'',
+            max_outsize=32,
+            is_static_call=True,
+        ), uint256
+    ) > 123, "vyper"
+    """
+]
+
+
+@pytest.mark.parametrize("code", good_code)
+def test_view_call_compiles(get_contract, code):
+    get_contract(code)

tests/parser/features/external_contracts/test_external_contract_calls.py

@@ -881,7 +881,7 @@ def set_lucky(arg1: address, arg2: int128):
     print("Successfully executed an external contract call state change")
 
 
-def test_constant_external_contract_call_cannot_change_state(
+def test_constant_external_contract_call_cannot_change_state1(
     assert_compile_failed, get_contract_with_gas_estimation
 ):
     c = """
@@ -892,6 +892,18 @@ def set_lucky(_lucky: int128) -> int128: nonpayable
 @view
 def set_lucky_expr(arg1: address, arg2: int128):
     Foo(arg1).set_lucky(arg2)
+    """
+    assert_compile_failed(lambda: get_contract_with_gas_estimation(c), StateAccessViolation)
+
+    print("Successfully blocked an external contract call from a constant function")
+
+
+def test_constant_external_contract_call_cannot_change_state2(
+    assert_compile_failed, get_contract_with_gas_estimation
+):
+    c = """
+interface Foo:
+    def set_lucky(_lucky: int128) -> int128: nonpayable
 
 @external
 @view

vyper/builtins/_signatures.py

@@ -6,6 +6,7 @@
 from vyper.codegen.expr import Expr
 from vyper.codegen.ir_node import IRnode
 from vyper.exceptions import CompilerPanic, TypeMismatch
+from vyper.semantics.analysis.base import StateMutability
 from vyper.semantics.analysis.utils import get_exact_type_from_node, validate_expected_type
 from vyper.semantics.types import TYPE_T, KwargSettings, VyperType
 from vyper.semantics.types.utils import type_from_annotation
@@ -77,6 +78,7 @@
 class BuiltinFunction:
     _has_varargs = False
     _kwargs: Dict[str, KwargSettings] = {}
+    mutability = StateMutability.PURE
 
     # helper function to deal with TYPE_DEFINITIONs
     def _validate_single(self, arg, expected_type):

vyper/builtins/functions.py

@@ -51,7 +51,7 @@
     UnfoldableNode,
     ZeroDivisionException,
 )
-from vyper.semantics.analysis.base import VarInfo
+from vyper.semantics.analysis.base import StateMutability, VarInfo
 from vyper.semantics.analysis.utils import (
     get_common_types,
     get_exact_type_from_node,
@@ -1083,12 +1083,15 @@
         "revert_on_failure": KwargSettings(BoolT(), True, require_literal=True),
     }
     _return_type = None
+    mutability = StateMutability.NONPAYABLE
 
     def fetch_call_return(self, node):
         self._validate_arg_types(node)
 
         kwargz = {i.arg: i.value for i in node.keywords}
 
+        value = kwargz.get("value")
+        static_call = kwargz.get("is_static_call")
         outsize = kwargz.get("max_outsize")
         revert_on_failure = kwargz.get("revert_on_failure")
         revert_on_failure = revert_on_failure.value if revert_on_failure is not None else True
@@ -1101,6 +1104,11 @@
         if not isinstance(outsize, vy_ast.Int) or outsize.value < 0:
             raise
 
+        if static_call:
+            self.mutability = StateMutability.VIEW
+        elif value:
+            self.mutability = StateMutability.PAYABLE
+
         if outsize.value:
             return_type = BytesT()
             return_type.set_min_length(outsize.value)
@@ -1724,6 +1732,7 @@
         "salt": KwargSettings(BYTES32_T, empty_value),
     }
     _return_type = AddressT()
+    mutability = StateMutability.PAYABLE
 
     @process_inputs
     def build_IR(self, expr, args, kwargs, context):

vyper/semantics/analysis/annotation.py

@@ -1,12 +1,13 @@
 from vyper import ast as vy_ast
-from vyper.exceptions import StructureException, TypeCheckFailure
+from vyper.exceptions import StateAccessViolation, StructureException, TypeCheckFailure
 from vyper.semantics.analysis.utils import (
     get_common_types,
     get_exact_type_from_node,
+    get_expr_info,
     get_possible_types_from_node,
 )
 from vyper.semantics.types import TYPE_T, BoolT, EnumT, EventT, SArrayT, StructT, is_type_t
-from vyper.semantics.types.function import ContractFunctionT, MemberFunctionT
+from vyper.semantics.types.function import ContractFunctionT, MemberFunctionT, StateMutability
 
 
 class _AnnotationVisitorBase:
@@ -135,7 +136,27 @@
         node._metadata["type"] = node_type
         self.visit(node.func)
 
+        def _check_mutability(call_type):
+            if (
+                call_type.mutability > StateMutability.VIEW
+                and self.func.mutability <= StateMutability.VIEW
+            ):
+                raise StateAccessViolation(
+                    f"Cannot call a mutating function from a {self.func.mutability.value} function",
+                    node,
+                )
+
+            if (
+                self.func.mutability == StateMutability.PURE
+                and call_type.mutability != StateMutability.PURE
+            ):
+                raise StateAccessViolation(
+                    "Cannot call non-pure function from a pure function", node
+                )
+
         if isinstance(call_type, ContractFunctionT):
+            _check_mutability(call_type)
+
             # function calls
             if call_type.is_internal:
                 self.func.called_functions.add(call_type)
@@ -157,10 +178,18 @@
             ):
                 self.visit(value, arg_type)
         elif isinstance(call_type, MemberFunctionT):
+            if call_type.is_modifying:
+                # it's a dotted function call like dynarray.pop()
+                expr_info = get_expr_info(node.func.value)
+                expr_info.validate_modification(node, self.func.mutability)
+
             assert len(node.args) == len(call_type.arg_types)
             for arg, arg_type in zip(node.args, call_type.arg_types):
                 self.visit(arg, arg_type)
         else:
+            if hasattr(call_type, "mutability"):
+                _check_mutability(call_type)
+
             # builtin functions
             arg_types = call_type.infer_arg_types(node)
             for arg, arg_type in zip(node.args, arg_types):

vyper/semantics/analysis/local.py

@@ -518,29 +518,6 @@ def visit_Expr(self, node):
         if is_type_t(fn_type, StructT):
             raise StructureException("Struct creation without assignment is disallowed", node)
 
-        if isinstance(fn_type, ContractFunctionT):
-            if (
-                fn_type.mutability > StateMutability.VIEW
-                and self.func.mutability <= StateMutability.VIEW
-            ):
-                raise StateAccessViolation(
-                    f"Cannot call a mutating function from a {self.func.mutability.value} function",
-                    node,
-                )
-
-            if (
-                self.func.mutability == StateMutability.PURE
-                and fn_type.mutability != StateMutability.PURE
-            ):
-                raise StateAccessViolation(
-                    "Cannot call non-pure function from a pure function", node
-                )
-
-        if isinstance(fn_type, MemberFunctionT) and fn_type.is_modifying:
-            # it's a dotted function call like dynarray.pop()
-            expr_info = get_expr_info(node.value.func.value)
-            expr_info.validate_modification(node, self.func.mutability)
-
         # NOTE: fetch_call_return validates call args.
         return_value = fn_type.fetch_call_return(node.value)
         if (