fix[lang]: disallow blockhash in pure functions

tests/functional/codegen/calling_convention/test_external_contract_calls.py

@@ -900,25 +900,29 @@ 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():
-    c = """
+@pytest.mark.parametrize("state_modifying_decorator", ("payable", "nonpayable"))
+@pytest.mark.parametrize("non_modifying_decorator", ("pure", "view"))
+def test_constant_external_contract_call_cannot_change_state(
+    state_modifying_decorator, non_modifying_decorator
+):
+    c = f"""
 interface Foo:
-    def set_lucky(_lucky: int128) -> int128: nonpayable
+    def set_lucky(_lucky: int128) -> int128: {state_modifying_decorator}
 
 @external
-@view
+@{non_modifying_decorator}
 def set_lucky_stmt(arg1: address, arg2: int128):
     extcall Foo(arg1).set_lucky(arg2)
     """
 
     with pytest.raises(StateAccessViolation):
         compile_code(c)
 
-    c2 = """
+    c2 = f"""
 interface Foo:
-    def set_lucky(_lucky: int128) -> int128: nonpayable
+    def set_lucky(_lucky: int128) -> int128: {state_modifying_decorator}
 @external
-@view
+@{non_modifying_decorator}
 def set_lucky_expr(arg1: address, arg2: int128) -> int128:
     return extcall Foo(arg1).set_lucky(arg2)
     """

tests/functional/codegen/features/decorators/test_pure.py

@@ -1,3 +1,6 @@
+import pytest
+
+from vyper import compile_code
 from vyper.exceptions import FunctionDeclarationException, StateAccessViolation
 
 
@@ -129,3 +132,15 @@ def foo() -> uint256:
         ),
         FunctionDeclarationException,
     )
+
+
+def test_invalid_builtin(get_contract):
+    code = """
+@external
+@pure
+def foo(x: uint256)-> bytes32:
+    return blockhash(x)
+    """
+
+    with pytest.raises(StateAccessViolation):
+        compile_code(code)

vyper/builtins/_signatures.py

@@ -6,7 +6,7 @@
 from vyper.codegen.expr import Expr
 from vyper.codegen.ir_node import IRnode
 from vyper.exceptions import CompilerPanic, TypeMismatch, UnfoldableNode
-from vyper.semantics.analysis.base import Modifiability
+from vyper.semantics.analysis.base import Modifiability, StateMutability
 from vyper.semantics.analysis.utils import (
     check_modifiability,
     get_exact_type_from_node,
@@ -87,6 +87,7 @@ class BuiltinFunctionT(VyperType):
     _return_type: Optional[VyperType] = None
     _equality_attrs = ("_id",)
     _is_terminus = False
+    mutability: StateMutability = StateMutability.PURE
 
     @property
     def modifiability(self):

vyper/builtins/functions.py

@@ -49,12 +49,12 @@
     UnfoldableNode,
     ZeroDivisionException,
 )
-from vyper.semantics.analysis.base import Modifiability, VarInfo
+from vyper.semantics.analysis.base import Modifiability, StateMutability, VarInfo
 from vyper.semantics.analysis.utils import (
     get_common_types,
     get_exact_type_from_node,
     get_possible_types_from_node,
     validate_expected_type,
 )
 from vyper.semantics.types import (
     TYPE_T,
@@ -1061,6 +1061,26 @@
 
         kwargz = {i.arg: i.value for i in node.keywords}
 
+        delegate_call = kwargz.get("is_delegate_call", False)
+        static_call = kwargz.get("is_static_call", False)
+        if delegate_call and static_call:
+            raise ArgumentException(
+                "Call may use one of `is_delegate_call` or `is_static_call`, not both", node
+            )
+
+        value = kwargz.get("value")
+        if (delegate_call or static_call) and value is not None:
+            raise ArgumentException("value= may not be passed for static or delegate calls!", node)
+
+        fn_node = node.get_ancestor(vy_ast.FunctionDef)
+        fn_type = fn_node._metadata["func_type"]
+        if not static_call and not fn_type.is_mutable:
+            raise StateAccessViolation(
+                f"Cannot make modifying calls from {fn_type.mutability},"
+                " use `is_static_call=True` to perform this action",
+                node,
+            )
+
         outsize = kwargz.get("max_outsize")
         if outsize is not None:
             outsize = outsize.get_folded_value()
@@ -1106,20 +1126,6 @@
             kwargs["revert_on_failure"],
         )
 
-        if delegate_call and static_call:
-            raise ArgumentException(
-                "Call may use one of `is_delegate_call` or `is_static_call`, not both"
-            )
-
-        if (delegate_call or static_call) and value.value != 0:
-            raise ArgumentException("value= may not be passed for static or delegate calls!")
-
-        if not static_call and context.is_constant():
-            raise StateAccessViolation(
-                f"Cannot make modifying calls from {context.pp_constancy()},"
-                " use `is_static_call=True` to perform this action"
-            )
-
         if data.value == "~calldata":
             call_ir = ["with", "mem_ofst", "msize"]
             args_ofst = ["seq", ["calldatacopy", "mem_ofst", 0, "calldatasize"], "mem_ofst"]
@@ -1249,6 +1255,7 @@
     _id = "blockhash"
     _inputs = [("block_num", UINT256_T)]
     _return_type = BYTES32_T
+    mutability = StateMutability.VIEW
 
     @process_inputs
     def build_IR(self, expr, args, kwargs, contact):

vyper/semantics/analysis/local.py

@@ -811,7 +811,10 @@ def visit_Call(self, node: vy_ast.Call, typ: VyperType) -> None:
             for arg, arg_type in zip(node.args, func_type.arg_types):
                 self.visit(arg, arg_type)
         else:
-            # builtin functions
+            # builtin functions and interfaces
+            if self.function_analyzer and hasattr(func_type, "mutability"):
+                self._check_call_mutability(func_type.mutability)  # type: ignore
+
             arg_types = func_type.infer_arg_types(node, expected_return_typ=typ)  # type: ignore
             for arg, arg_type in zip(node.args, arg_types):
                 self.visit(arg, arg_type)