fix[lang]: disallow blockhash in pure functions

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

@@ -129,3 +129,35 @@ def foo() -> uint256:
         ),
         FunctionDeclarationException,
     )
+
+
+def test_invalid_builtin(get_contract, assert_compile_failed):
+    assert_compile_failed(
+        lambda: get_contract(
+            """
+@external
+@pure
+def foo(x: uint256)-> bytes32:
+    return blockhash(x)
+    """
+        ),
+        StateAccessViolation,
+    )
+
+
+def test_invalid_interface(get_contract, assert_compile_failed):
+    assert_compile_failed(
+        lambda: get_contract(
+            """
+interface Foo:
+    def foo() -> uint256: payable
+
+
+@external
+@pure
+def bar(a: address) -> uint256:
+    return extcall Foo(a).foo()
+    """
+        ),
+        StateAccessViolation,
+    )

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,7 +49,7 @@
     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,
@@ -1061,6 +1061,25 @@ def fetch_call_return(self, node):
 
         kwargz = {i.arg: i.value for i in node.keywords}
 
+        delegate_call = kwargz.get("is_delegate_call")
+        static_call = kwargz.get("is_static_call")
+        if delegate_call and static_call:
+            raise ArgumentException(
+                "Call may use one of `is_delegate_call` or `is_static_call`, not both"
+            )
+
+        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!")
+
+        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"
+            )
+
         outsize = kwargz.get("max_outsize")
         if outsize is not None:
             outsize = outsize.get_folded_value()
@@ -1106,20 +1125,6 @@ def build_IR(self, expr, args, kwargs, context):
             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 +1254,7 @@ class BlockHash(BuiltinFunctionT):
     _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)