def visit_Expr(self, node):
if not isinstance(node.value, vy_ast.Call):
raise StructureException(
"Expressions without assignment are disallowed", node)
fn_type = get_exact_type_from_node(node.value.func)
if isinstance(fn_type, Event):
raise StructureException(
"To call an event you must use the `log` statement", node)
if isinstance(fn_type, ContractFunction):
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:
raise StateAccessViolation(
f"Cannot call any function from a {self.func.mutability.value} function",
node)
return_value = fn_type.fetch_call_return(node.value)
if return_value and not isinstance(fn_type, ContractFunction):
raise StructureException(
f"Function '{fn_type._id}' cannot be called without assigning the result",
node)
def __init__(self, vyper_module: vy_ast.Module,
fn_node: vy_ast.FunctionDef, namespace: dict) -> None:
self.vyper_module = vyper_module
self.fn_node = fn_node
self.namespace = namespace
self.func = fn_node._metadata["type"]
self.annotation_visitor = StatementAnnotationVisitor(
fn_node, namespace)
namespace.update(self.func.arguments)
if self.func.visibility is FunctionVisibility.INTERNAL:
node_list = fn_node.get_descendants(vy_ast.Attribute, {
"value.id": "msg",
"attr": {"data", "sender"}
})
if node_list:
raise StateAccessViolation(
f"msg.{node_list[0].attr} is not allowed in internal functions",
node_list[0])
if self.func.mutability == StateMutability.PURE:
node_list = fn_node.get_descendants(
vy_ast.Attribute,
{
"value.id":
set(CONSTANT_ENVIRONMENT_VARS.keys()).union(
set(MUTABLE_ENVIRONMENT_VARS.keys()))
},
)
if node_list:
raise StateAccessViolation(
"not allowed to query contract or environment variables in pure functions",
node_list[0],
)
if self.func.mutability is not StateMutability.PAYABLE:
node_list = fn_node.get_descendants(vy_ast.Attribute, {
"value.id": "msg",
"attr": "value"
})
if node_list:
raise NonPayableViolation(
"msg.value is not allowed in non-payable functions",
node_list[0])
for node in fn_node.body:
self.visit(node)
if self.func.return_type:
if not check_for_terminus(fn_node.body):
raise FunctionDeclarationException(
f"Missing or unmatched return statements in function '{fn_node.name}'",
fn_node,
)
def visit_AnnAssign(self, node):
name = node.get("target.id")
if name is None:
raise VariableDeclarationException(
"Invalid module-level assignment", node)
if name == "implements":
interface_name = node.annotation.id
self.namespace[interface_name].validate_implements(node)
return
is_immutable, is_public = False, False
annotation = node.annotation
if isinstance(annotation, vy_ast.Call):
# the annotation is a function call, e.g. `foo: constant(uint256)`
call_name = annotation.get("func.id")
if call_name in ("constant", "public"):
validate_call_args(annotation, 1)
if call_name == "constant":
# declaring a constant
is_immutable = True
elif call_name == "public":
# declaring a public variable
is_public = True
# remove the outer call node, to handle cases such as `public(map(..))`
annotation = annotation.args[0]
type_definition = get_type_from_annotation(annotation,
DataLocation.STORAGE,
is_immutable, is_public)
if is_immutable:
if not node.value:
raise VariableDeclarationException(
"Constant must be declared with a value", node)
if not check_literal(node.value):
raise StateAccessViolation("Value must be a literal",
node.value)
validate_expected_type(node.value, type_definition)
try:
self.namespace[name] = type_definition
except VyperException as exc:
raise exc.with_annotation(node) from None
return
if node.value:
raise VariableDeclarationException(
"Storage variables cannot have an initial value", node.value)
try:
self.namespace["self"].add_member(name, type_definition)
except NamespaceCollision:
raise NamespaceCollision(
f"Value '{name}' has already been declared", node) from None
except VyperException as exc:
raise exc.with_annotation(node) from None
def visit_AugAssign(self, node):
if isinstance(node.value, vy_ast.Tuple):
raise StructureException("Right-hand side of assignment cannot be a tuple", node.value)
target = get_exact_type_from_node(node.target)
validate_expected_type(node.value, target)
if self.func.mutability <= StateMutability.VIEW and target.location == DataLocation.STORAGE:
raise StateAccessViolation(
f"Cannot modify storage in a {self.func.mutability.value} function", node
)
target.validate_modification(node)
def make_call(stmt_expr, context):
method_name, _, sig = _call_lookup_specs(stmt_expr, context)
if context.is_constant() and sig.mutability not in ("view", "pure"):
raise StateAccessViolation(
f"May not call state modifying function "
f"'{method_name}' within {context.pp_constancy()}.",
getpos(stmt_expr),
)
if not sig.private:
raise StructureException("Cannot call public functions via 'self'",
stmt_expr)
return _call_self_private(stmt_expr, context, sig)
def visit_Expr(self, node):
if not isinstance(node.value, vy_ast.Call):
raise StructureException(
"Expressions without assignment are disallowed", node)
fn_type = get_exact_type_from_node(node.value.func)
if isinstance(fn_type, Event):
raise StructureException(
"To call an event you must use the `log` statement", node)
if isinstance(fn_type, ContractFunction):
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,
MemberFunctionDefinition) and fn_type.is_modifying:
fn_type.underlying_type.validate_modification(
node, self.func.mutability)
# NOTE: fetch_call_return validates call args.
return_value = fn_type.fetch_call_return(node.value)
if (return_value and not isinstance(fn_type, MemberFunctionDefinition)
and not isinstance(fn_type, ContractFunction)):
raise StructureException(
f"Function '{fn_type._id}' cannot be called without assigning the result",
node)
self.expr_visitor.visit(node.value)
def validate_modification(
self,
node: Union[vy_ast.Assign, vy_ast.AugAssign, vy_ast.Call],
mutability: Any, # should be StateMutability, import cycle
) -> None:
"""
Validate an attempt to modify this value.
Raises if the value is a constant or involves an invalid operation.
Arguments
---------
node : Assign | AugAssign | Call
Vyper ast node of the modifying action.
mutability: StateMutability
The mutability of the context (e.g., pure function) we are currently in
"""
# TODO: break this cycle, probably by moving this to validation module
from vyper.semantics.types.function import StateMutability
if mutability <= StateMutability.VIEW and self.location == DataLocation.STORAGE:
raise StateAccessViolation(
f"Cannot modify storage in a {mutability.value} function",
node)
if self.location == DataLocation.CALLDATA:
raise ImmutableViolation("Cannot write to calldata", node)
if self.is_constant:
raise ImmutableViolation("Constant value cannot be written to",
node)
if self.is_immutable:
if node.get_ancestor(vy_ast.FunctionDef).get("name") != "__init__":
raise ImmutableViolation(
"Immutable value cannot be written to", node)
if self._modification_count:
raise ImmutableViolation(
"Immutable value cannot be modified after assignment",
node)
self._modification_count += 1
if isinstance(node, vy_ast.AugAssign):
self.validate_numeric_op(node)
def visit_For(self, node):
if isinstance(node.iter, vy_ast.Subscript):
raise StructureException("Cannot iterate over a nested list", node.iter)
if isinstance(node.iter, vy_ast.Call):
# iteration via range()
if node.iter.get("func.id") != "range":
raise IteratorException(
"Cannot iterate over the result of a function call", node.iter
)
validate_call_args(node.iter, (1, 2))
args = node.iter.args
if len(args) == 1:
# range(CONSTANT)
if not isinstance(args[0], vy_ast.Num):
raise StateAccessViolation("Value must be a literal", node)
if args[0].value <= 0:
raise StructureException("For loop must have at least 1 iteration", args[0])
validate_expected_type(args[0], Uint256Definition())
type_list = get_possible_types_from_node(args[0])
else:
validate_expected_type(args[0], IntegerAbstractType())
type_list = get_common_types(*args)
if not isinstance(args[0], vy_ast.Constant):
# range(x, x + CONSTANT)
if not isinstance(args[1], vy_ast.BinOp) or not isinstance(
args[1].op, vy_ast.Add
):
raise StructureException(
"Second element must be the first element plus a literal value",
args[0],
)
if not vy_ast.compare_nodes(args[0], args[1].left):
raise StructureException(
"First and second variable must be the same", args[1].left
)
if not isinstance(args[1].right, vy_ast.Int):
raise InvalidLiteral("Literal must be an integer", args[1].right)
if args[1].right.value < 1:
raise StructureException(
f"For loop has invalid number of iterations ({args[1].right.value}),"
" the value must be greater than zero",
args[1].right,
)
else:
# range(CONSTANT, CONSTANT)
if not isinstance(args[1], vy_ast.Int):
raise InvalidType("Value must be a literal integer", args[1])
validate_expected_type(args[1], IntegerAbstractType())
if args[0].value >= args[1].value:
raise StructureException("Second value must be > first value", args[1])
else:
# iteration over a variable or literal list
type_list = [
i.value_type
for i in get_possible_types_from_node(node.iter)
if isinstance(i, ArrayDefinition)
]
if not type_list:
raise InvalidType("Not an iterable type", node.iter)
if next((i for i in type_list if isinstance(i, ArrayDefinition)), False):
raise StructureException("Cannot iterate over a nested list", node.iter)
if isinstance(node.iter, (vy_ast.Name, vy_ast.Attribute)):
# check for references to the iterated value within the body of the loop
assign = _check_iterator_assign(node.iter, node)
if assign:
raise ImmutableViolation("Cannot modify array during iteration", assign)
if node.iter.get("value.id") == "self":
# check if iterated value may be modified by function calls inside the loop
iter_name = node.iter.attr
for call_node in node.get_descendants(vy_ast.Call, {"func.value.id": "self"}):
fn_name = call_node.func.attr
fn_node = self.vyper_module.get_children(vy_ast.FunctionDef, {"name": fn_name})[0]
if _check_iterator_assign(node.iter, fn_node):
# check for direct modification
raise ImmutableViolation(
f"Cannot call '{fn_name}' inside for loop, it potentially "
f"modifies iterated storage variable '{iter_name}'",
call_node,
)
for name in self.namespace["self"].members[fn_name].recursive_calls:
# check for indirect modification
fn_node = self.vyper_module.get_children(vy_ast.FunctionDef, {"name": name})[0]
if _check_iterator_assign(node.iter, fn_node):
raise ImmutableViolation(
f"Cannot call '{fn_name}' inside for loop, it may call to '{name}' "
f"which potentially modifies iterated storage variable '{iter_name}'",
call_node,
)
for_loop_exceptions = []
iter_name = node.target.id
for type_ in type_list:
# type check the for loop body using each possible type for iterator value
type_ = copy.deepcopy(type_)
type_.is_immutable = True
with self.namespace.enter_scope():
try:
self.namespace[iter_name] = type_
except VyperException as exc:
raise exc.with_annotation(node) from None
try:
for n in node.body:
self.visit(n)
return
except TypeMismatch as exc:
for_loop_exceptions.append(exc)
if len(set(str(i) for i in for_loop_exceptions)) == 1:
# if every attempt at type checking raised the same exception
raise for_loop_exceptions[0]
# return an aggregate TypeMismatch that shows all possible exceptions
# depending on which type is used
types_str = [str(i) for i in type_list]
given_str = f"{', '.join(types_str[:1])} or {types_str[-1]}"
raise TypeMismatch(
f"Iterator value '{iter_name}' may be cast as {given_str}, "
"but type checking fails with all possible types:",
node,
*(
(f"Casting '{iter_name}' as {type_}: {exc.message}", exc.annotations[0])
for type_, exc in zip(type_list, for_loop_exceptions)
),
)
def lll_for_self_call(stmt_expr, context):
from vyper.codegen.expr import Expr # TODO rethink this circular import
pos = getpos(stmt_expr)
# ** Internal Call **
# Steps:
# - copy arguments into the soon-to-be callee
# - allocate return buffer
# - push jumpdest (callback ptr) and return buffer location
# - jump to label
# - (private function will fill return buffer and jump back)
method_name = stmt_expr.func.attr
pos_args_lll = [Expr(x, context).lll_node for x in stmt_expr.args]
sig, kw_vals = context.lookup_internal_function(method_name, pos_args_lll)
kw_args_lll = [Expr(x, context).lll_node for x in kw_vals]
args_lll = pos_args_lll + kw_args_lll
args_tuple_t = TupleType([x.typ for x in args_lll])
args_as_tuple = LLLnode.from_list(["multi"] + [x for x in args_lll], typ=args_tuple_t)
# register callee to help calculate our starting frame offset
context.register_callee(sig.frame_size)
if context.is_constant() and sig.mutability not in ("view", "pure"):
raise StateAccessViolation(
f"May not call state modifying function "
f"'{method_name}' within {context.pp_constancy()}.",
getpos(stmt_expr),
)
# TODO move me to type checker phase
if not sig.internal:
raise StructureException("Cannot call external functions via 'self'", stmt_expr)
return_label = _generate_label(f"{sig.internal_function_label}_call")
# allocate space for the return buffer
# TODO allocate in stmt and/or expr.py
if sig.return_type is not None:
return_buffer = LLLnode.from_list(
context.new_internal_variable(sig.return_type), annotation=f"{return_label}_return_buf"
)
else:
return_buffer = None
# note: dst_tuple_t != args_tuple_t
dst_tuple_t = TupleType([arg.typ for arg in sig.args])
args_dst = LLLnode(sig.frame_start, typ=dst_tuple_t, location="memory")
# if one of the arguments is a self call, the argument
# buffer could get borked. to prevent against that,
# write args to a temporary buffer until all the arguments
# are fully evaluated.
if args_as_tuple.contains_self_call:
copy_args = ["seq"]
# TODO deallocate me
tmp_args_buf = LLLnode(
context.new_internal_variable(dst_tuple_t),
typ=dst_tuple_t,
location="memory",
)
copy_args.append(
# --> args evaluate here <--
make_setter(tmp_args_buf, args_as_tuple, pos)
)
copy_args.append(make_setter(args_dst, tmp_args_buf, pos))
else:
copy_args = make_setter(args_dst, args_as_tuple, pos)
goto_op = ["goto", sig.internal_function_label]
# pass return buffer to subroutine
if return_buffer is not None:
goto_op += [return_buffer]
# pass return label to subroutine
goto_op += [push_label_to_stack(return_label)]
call_sequence = [
"seq",
copy_args,
goto_op,
["label", return_label, ["var_list"], "pass"],
]
if return_buffer is not None:
# push return buffer location to stack
call_sequence += [return_buffer]
o = LLLnode.from_list(
call_sequence,
typ=sig.return_type,
location="memory",
pos=pos,
annotation=stmt_expr.get("node_source_code"),
add_gas_estimate=sig.gas,
)
o.is_self_call = True
return o
def visit_AnnAssign(self, node):
name = node.get("target.id")
if name is None:
raise VariableDeclarationException("Invalid module-level assignment", node)
if name == "implements":
interface_name = node.annotation.id
self.namespace[interface_name].validate_implements(node)
return
is_constant, is_public, is_immutable = False, False, False
annotation = node.annotation
if isinstance(annotation, vy_ast.Call):
# the annotation is a function call, e.g. `foo: constant(uint256)`
call_name = annotation.get("func.id")
if call_name in ("constant", "public", "immutable"):
validate_call_args(annotation, 1)
if call_name == "constant":
# declaring a constant
is_constant = True
elif call_name == "public":
# declaring a public variable
is_public = True
# generate function type and add to metadata
# we need this when builing the public getter
node._metadata["func_type"] = ContractFunction.from_AnnAssign(node)
elif call_name == "immutable":
# declaring an immutable variable
is_immutable = True
# mutability is checked automatically preventing assignment
# outside of the constructor, here we just check a value is assigned,
# not necessarily where
assignments = self.ast.get_descendants(
vy_ast.Assign, filters={"target.id": node.target.id}
)
if not assignments:
# Special error message for common wrong usages via `self.<immutable name>`
wrong_self_attribute = self.ast.get_descendants(
vy_ast.Attribute, {"value.id": "self", "attr": node.target.id}
)
message = (
"Immutable variables must be accessed without 'self'"
if len(wrong_self_attribute) > 0
else "Immutable definition requires an assignment in the constructor"
)
raise SyntaxException(
message, node.node_source_code, node.lineno, node.col_offset
)
# remove the outer call node, to handle cases such as `public(map(..))`
annotation = annotation.args[0]
data_loc = DataLocation.CODE if is_immutable else DataLocation.STORAGE
type_definition = get_type_from_annotation(
annotation, data_loc, is_constant, is_public, is_immutable
)
node._metadata["type"] = type_definition
if is_constant:
if not node.value:
raise VariableDeclarationException("Constant must be declared with a value", node)
if not check_constant(node.value):
raise StateAccessViolation("Value must be a literal", node.value)
validate_expected_type(node.value, type_definition)
try:
self.namespace[name] = type_definition
except VyperException as exc:
raise exc.with_annotation(node) from None
return
if node.value:
var_type = "Immutable" if is_immutable else "Storage"
raise VariableDeclarationException(
f"{var_type} variables cannot have an initial value", node.value
)
if is_immutable:
try:
# block immutable if storage variable already exists
if name in self.namespace["self"].members:
raise NamespaceCollision(
f"Value '{name}' has already been declared", node
) from None
self.namespace[name] = type_definition
except VyperException as exc:
raise exc.with_annotation(node) from None
return
try:
self.namespace.validate_assignment(name)
except NamespaceCollision as exc:
raise exc.with_annotation(node) from None
try:
self.namespace["self"].add_member(name, type_definition)
node.target._metadata["type"] = type_definition
except NamespaceCollision:
raise NamespaceCollision(f"Value '{name}' has already been declared", node) from None
except VyperException as exc:
raise exc.with_annotation(node) from None
def external_call(node,
context,
interface_name,
contract_address,
pos,
value=None,
gas=None):
from vyper.parser.expr import Expr
if value is None:
value = 0
if gas is None:
gas = "gas"
method_name = node.func.attr
sig = context.sigs[interface_name][method_name]
inargs, inargsize, _ = pack_arguments(
sig,
[Expr(arg, context).lll_node for arg in node.args],
context,
node.func,
is_external_call=True,
)
output_placeholder, output_size, returner = get_external_call_output(
sig, context)
sub = [
"seq",
["assert", ["extcodesize", contract_address]],
]
if context.is_constant() and sig.mutability not in ("view", "pure"):
# TODO this can probably go
raise StateAccessViolation(
f"May not call state modifying function '{method_name}' "
f"within {context.pp_constancy()}.",
node,
)
if context.is_constant() or sig.mutability in ("view", "pure"):
sub.append([
"assert",
[
"staticcall",
gas,
contract_address,
inargs,
inargsize,
output_placeholder,
output_size,
],
])
else:
sub.append([
"assert",
[
"call",
gas,
contract_address,
value,
inargs,
inargsize,
output_placeholder,
output_size,
],
])
sub.extend(returner)
o = LLLnode.from_list(sub,
typ=sig.output_type,
location="memory",
pos=getpos(node))
return o
def make_call(stmt_expr, context):
# ** Internal Call **
# Steps:
# (x) push current local variables
# (x) push arguments
# (x) push jumpdest (callback ptr)
# (x) jump to label
# (x) pop return values
# (x) pop local variables
pop_local_vars = []
push_local_vars = []
pop_return_values = []
push_args = []
method_name = stmt_expr.func.attr
from vyper.parser.expr import parse_sequence
pre_init, expr_args = parse_sequence(stmt_expr, stmt_expr.args, context)
sig = FunctionSignature.lookup_sig(
context.sigs,
method_name,
expr_args,
stmt_expr,
context,
)
if context.is_constant() and sig.mutability not in ("view", "pure"):
raise StateAccessViolation(
f"May not call state modifying function "
f"'{method_name}' within {context.pp_constancy()}.",
getpos(stmt_expr),
)
if not sig.internal:
raise StructureException("Cannot call external functions via 'self'",
stmt_expr)
# Push local variables.
var_slots = [(v.pos, v.size) for name, v in context.vars.items()
if v.location == "memory"]
if var_slots:
var_slots.sort(key=lambda x: x[0])
if len(var_slots) > 10:
# if memory is large enough, push and pop it via iteration
mem_from, mem_to = var_slots[0][
0], var_slots[-1][0] + var_slots[-1][1] * 32
i_placeholder = context.new_internal_variable(BaseType("uint256"))
local_save_ident = f"_{stmt_expr.lineno}_{stmt_expr.col_offset}"
push_loop_label = "save_locals_start" + local_save_ident
pop_loop_label = "restore_locals_start" + local_save_ident
push_local_vars = [
["mstore", i_placeholder, mem_from],
["label", push_loop_label],
["mload", ["mload", i_placeholder]],
[
"mstore", i_placeholder,
["add", ["mload", i_placeholder], 32]
],
[
"if", ["lt", ["mload", i_placeholder], mem_to],
["goto", push_loop_label]
],
]
pop_local_vars = [
["mstore", i_placeholder, mem_to - 32],
["label", pop_loop_label],
["mstore", ["mload", i_placeholder], "pass"],
[
"mstore", i_placeholder,
["sub", ["mload", i_placeholder], 32]
],
[
"if", ["ge", ["mload", i_placeholder], mem_from],
["goto", pop_loop_label]
],
]
else:
# for smaller memory, hardcode the mload/mstore locations
push_mem_slots = []
for pos, size in var_slots:
push_mem_slots.extend([pos + i * 32 for i in range(size)])
push_local_vars = [["mload", pos] for pos in push_mem_slots]
pop_local_vars = [["mstore", pos, "pass"]
for pos in push_mem_slots[::-1]]
# Push Arguments
if expr_args:
inargs, inargsize, arg_pos = pack_arguments(sig,
expr_args,
context,
stmt_expr,
is_external_call=False)
push_args += [
inargs
] # copy arguments first, to not mess up the push/pop sequencing.
static_arg_size = 32 * sum(
[get_static_size_of_type(arg.typ) for arg in expr_args])
static_pos = int(arg_pos + static_arg_size)
needs_dyn_section = any(
[has_dynamic_data(arg.typ) for arg in expr_args])
if needs_dyn_section:
ident = f"push_args_{sig.method_id}_{stmt_expr.lineno}_{stmt_expr.col_offset}"
start_label = ident + "_start"
end_label = ident + "_end"
i_placeholder = context.new_internal_variable(BaseType("uint256"))
# Calculate copy start position.
# Given | static | dynamic | section in memory,
# copy backwards so the values are in order on the stack.
# We calculate i, the end of the whole encoded part
# (i.e. the starting index for copy)
# by taking ceil32(len<arg>) + offset<arg> + arg_pos
# for the last dynamic argument and arg_pos is the start
# the whole argument section.
idx = 0
for arg in expr_args:
if isinstance(arg.typ, ByteArrayLike):
last_idx = idx
idx += get_static_size_of_type(arg.typ)
push_args += [[
"with",
"offset",
["mload", arg_pos + last_idx * 32],
[
"with",
"len_pos",
["add", arg_pos, "offset"],
[
"with",
"len_value",
["mload", "len_pos"],
[
"mstore", i_placeholder,
["add", "len_pos", ["ceil32", "len_value"]]
],
],
],
]]
# loop from end of dynamic section to start of dynamic section,
# pushing each element onto the stack.
push_args += [
["label", start_label],
[
"if", ["lt", ["mload", i_placeholder], static_pos],
["goto", end_label]
],
["mload", ["mload", i_placeholder]],
[
"mstore", i_placeholder,
["sub", ["mload", i_placeholder], 32]
], # decrease i
["goto", start_label],
["label", end_label],
]
# push static section
push_args += [["mload", pos]
for pos in reversed(range(arg_pos, static_pos, 32))]
elif sig.args:
raise StructureException(
f"Wrong number of args for: {sig.name} (0 args given, expected {len(sig.args)})",
stmt_expr,
)
# Jump to function label.
jump_to_func = [
["add", ["pc"], 6], # set callback pointer.
["goto", f"priv_{sig.method_id}"],
["jumpdest"],
]
# Pop return values.
returner = [0]
if sig.output_type:
output_placeholder, returner, output_size = _call_make_placeholder(
stmt_expr, context, sig)
if output_size > 0:
dynamic_offsets = []
if isinstance(sig.output_type, (BaseType, ListType)):
pop_return_values = [[
"mstore", ["add", output_placeholder, pos], "pass"
] for pos in range(0, output_size, 32)]
elif isinstance(sig.output_type, ByteArrayLike):
dynamic_offsets = [(0, sig.output_type)]
pop_return_values = [
["pop", "pass"],
]
elif isinstance(sig.output_type, TupleLike):
static_offset = 0
pop_return_values = []
for name, typ in sig.output_type.tuple_items():
if isinstance(typ, ByteArrayLike):
pop_return_values.append([
"mstore",
["add", output_placeholder, static_offset], "pass"
])
dynamic_offsets.append(([
"mload",
["add", output_placeholder, static_offset]
], name))
static_offset += 32
else:
member_output_size = get_size_of_type(typ) * 32
pop_return_values.extend([[
"mstore", ["add", output_placeholder, pos], "pass"
] for pos in range(static_offset, static_offset +
member_output_size, 32)])
static_offset += member_output_size
# append dynamic unpacker.
dyn_idx = 0
for in_memory_offset, _out_type in dynamic_offsets:
ident = f"{stmt_expr.lineno}_{stmt_expr.col_offset}_arg_{dyn_idx}"
dyn_idx += 1
start_label = "dyn_unpack_start_" + ident
end_label = "dyn_unpack_end_" + ident
i_placeholder = context.new_internal_variable(
typ=BaseType("uint256"))
begin_pos = ["add", output_placeholder, in_memory_offset]
# loop until length.
o = LLLnode.from_list(
[
"seq_unchecked",
["mstore", begin_pos, "pass"], # get len
["mstore", i_placeholder, 0],
["label", start_label],
[ # break
"if",
[
"ge", ["mload", i_placeholder],
["ceil32", ["mload", begin_pos]]
],
["goto", end_label],
],
[ # pop into correct memory slot.
"mstore",
[
"add", ["add", begin_pos, 32],
["mload", i_placeholder]
],
"pass",
],
# increment i
[
"mstore", i_placeholder,
["add", 32, ["mload", i_placeholder]]
],
["goto", start_label],
["label", end_label],
],
typ=None,
annotation="dynamic unpacker",
pos=getpos(stmt_expr),
)
pop_return_values.append(o)
call_body = list(
itertools.chain(
["seq_unchecked"],
pre_init,
push_local_vars,
push_args,
jump_to_func,
pop_return_values,
pop_local_vars,
[returner],
))
# If we have no return, we need to pop off
pop_returner_call_body = ["pop", call_body
] if sig.output_type is None else call_body
o = LLLnode.from_list(
pop_returner_call_body,
typ=sig.output_type,
location="memory",
pos=getpos(stmt_expr),
annotation=f"Internal Call: {method_name}",
add_gas_estimate=sig.gas,
)
o.gas += sig.gas
return o
def from_FunctionDef(
cls,
node: vy_ast.FunctionDef,
is_interface: Optional[bool] = False) -> "ContractFunction":
"""
Generate a `ContractFunction` object from a `FunctionDef` node.
Arguments
---------
node : FunctionDef
Vyper ast node to generate the function definition from.
is_interface: bool, optional
Boolean indicating if the function definition is part of an interface.
Returns
-------
ContractFunction
"""
kwargs: Dict[str, Any] = {}
if is_interface:
# FunctionDef with stateMutability in body (Interface defintions)
if (len(node.body) == 1 and isinstance(node.body[0], vy_ast.Expr)
and isinstance(node.body[0].value, vy_ast.Name)
and StateMutability.is_valid_value(node.body[0].value.id)):
# Interfaces are always public
kwargs["function_visibility"] = FunctionVisibility.EXTERNAL
kwargs["state_mutability"] = StateMutability(
node.body[0].value.id)
elif len(node.body) == 1 and node.body[0].get("value.id") in (
"constant", "modifying"):
if node.body[0].value.id == "constant":
expected = "view or pure"
else:
expected = "payable or nonpayable"
raise StructureException(
f"State mutability should be set to {expected}",
node.body[0])
else:
raise StructureException(
"Body must only contain state mutability label",
node.body[0])
else:
# FunctionDef with decorators (normal functions)
for decorator in node.decorator_list:
if isinstance(decorator, vy_ast.Call):
if "nonreentrant" in kwargs:
raise StructureException(
"nonreentrant decorator is already set with key: "
f"{kwargs['nonreentrant']}",
node,
)
if decorator.get("func.id") != "nonreentrant":
raise StructureException("Decorator is not callable",
decorator)
if len(decorator.args) != 1 or not isinstance(
decorator.args[0], vy_ast.Str):
raise StructureException(
"@nonreentrant name must be given as a single string literal",
decorator)
if node.name == "__init__":
msg = "Nonreentrant decorator disallowed on `__init__`"
raise FunctionDeclarationException(msg, decorator)
kwargs["nonreentrant"] = decorator.args[0].value
elif isinstance(decorator, vy_ast.Name):
if FunctionVisibility.is_valid_value(decorator.id):
if "function_visibility" in kwargs:
raise FunctionDeclarationException(
f"Visibility is already set to: {kwargs['function_visibility']}",
node,
)
kwargs["function_visibility"] = FunctionVisibility(
decorator.id)
elif StateMutability.is_valid_value(decorator.id):
if "state_mutability" in kwargs:
raise FunctionDeclarationException(
f"Mutability is already set to: {kwargs['state_mutability']}",
node)
kwargs["state_mutability"] = StateMutability(
decorator.id)
else:
if decorator.id == "constant":
warnings.warn(
"'@constant' decorator has been removed (see VIP2040). "
"Use `@view` instead.",
DeprecationWarning,
)
raise FunctionDeclarationException(
f"Unknown decorator: {decorator.id}", decorator)
else:
raise StructureException("Bad decorator syntax", decorator)
if "function_visibility" not in kwargs:
raise FunctionDeclarationException(
f"Visibility must be set to one of: {', '.join(FunctionVisibility.values())}",
node)
if node.name == "__default__":
if kwargs["function_visibility"] != FunctionVisibility.EXTERNAL:
raise FunctionDeclarationException(
"Default function must be marked as `@external`", node)
if node.args.args:
raise FunctionDeclarationException(
"Default function may not receive any arguments",
node.args.args[0])
if "state_mutability" not in kwargs:
# Assume nonpayable if not set at all (cannot accept Ether, but can modify state)
kwargs["state_mutability"] = StateMutability.NONPAYABLE
if kwargs[
"state_mutability"] == StateMutability.PURE and "nonreentrant" in kwargs:
raise StructureException(
"Cannot use reentrancy guard on pure functions", node)
# call arguments
if node.args.defaults and node.name == "__init__":
raise FunctionDeclarationException(
"Constructor may not use default arguments",
node.args.defaults[0])
arguments = OrderedDict()
max_arg_count = len(node.args.args)
min_arg_count = max_arg_count - len(node.args.defaults)
defaults = [None] * min_arg_count + node.args.defaults
namespace = get_namespace()
for arg, value in zip(node.args.args, defaults):
if arg.arg in ("gas", "value", "skip_contract_check",
"default_return_value"):
raise ArgumentException(
f"Cannot use '{arg.arg}' as a variable name in a function input",
arg)
if arg.arg in arguments:
raise ArgumentException(
f"Function contains multiple inputs named {arg.arg}", arg)
if arg.arg in namespace:
raise NamespaceCollision(arg.arg, arg)
if arg.annotation is None:
raise ArgumentException(
f"Function argument '{arg.arg}' is missing a type", arg)
type_definition = get_type_from_annotation(
arg.annotation,
location=DataLocation.CALLDATA,
is_constant=True)
if value is not None:
if not check_kwargable(value):
raise StateAccessViolation(
"Value must be literal or environment variable", value)
validate_expected_type(value, type_definition)
arguments[arg.arg] = type_definition
# return types
if node.returns is None:
return_type = None
elif node.name == "__init__":
raise FunctionDeclarationException(
"Constructor may not have a return type", node.returns)
elif isinstance(node.returns,
(vy_ast.Name, vy_ast.Call, vy_ast.Subscript)):
return_type = get_type_from_annotation(
node.returns, location=DataLocation.MEMORY)
elif isinstance(node.returns, vy_ast.Tuple):
tuple_types: Tuple = ()
for n in node.returns.elements:
tuple_types += (get_type_from_annotation(
n, location=DataLocation.MEMORY), )
return_type = TupleDefinition(tuple_types)
else:
raise InvalidType(
"Function return value must be a type name or tuple",
node.returns)
return cls(node.name, arguments, min_arg_count, max_arg_count,
return_type, **kwargs)
def _external_call_helper(
contract_address,
contract_sig,
args_lll,
context,
pos=None,
value=None,
gas=None,
skip_contract_check=None,
):
if value is None:
value = 0
if gas is None:
gas = "gas"
if skip_contract_check is None:
skip_contract_check = False
# sanity check
assert len(contract_sig.base_args) <= len(args_lll) <= len(
contract_sig.args)
if context.is_constant() and contract_sig.mutability not in ("view",
"pure"):
# TODO is this already done in type checker?
raise StateAccessViolation(
f"May not call state modifying function '{contract_sig.name}' "
f"within {context.pp_constancy()}.",
pos,
)
sub = ["seq"]
buf, arg_packer, args_ofst, args_len = _pack_arguments(
contract_sig, args_lll, context, pos)
ret_unpacker, ret_ofst, ret_len = _unpack_returndata(
buf, contract_sig, skip_contract_check, context, pos)
sub += arg_packer
if contract_sig.return_type is None and not skip_contract_check:
# if we do not expect return data, check that a contract exists at the
# target address. we must perform this check BEFORE the call because
# the contract might selfdestruct. on the other hand we can omit this
# when we _do_ expect return data because we later check
# `returndatasize` (that check works even if the contract
# selfdestructs).
sub.append(["assert", ["extcodesize", contract_address]])
if context.is_constant() or contract_sig.mutability in ("view", "pure"):
call_op = [
"staticcall", gas, contract_address, args_ofst, args_len, ret_ofst,
ret_len
]
else:
call_op = [
"call", gas, contract_address, value, args_ofst, args_len,
ret_ofst, ret_len
]
sub.append(check_external_call(call_op))
if contract_sig.return_type is not None:
sub += ret_unpacker
ret = LLLnode.from_list(
# set the encoding to ABI here, downstream code will decode and add clampers.
sub,
typ=contract_sig.return_type,
location="memory",
encoding=_returndata_encoding(contract_sig),
pos=pos,
)
return ret
def external_call(node,
context,
interface_name,
contract_address,
pos,
value=None,
gas=None):
from vyper.parser.expr import Expr
if value is None:
value = 0
if gas is None:
gas = "gas"
method_name = node.func.attr
sig = context.sigs[interface_name][method_name]
inargs, inargsize, _ = pack_arguments(
sig,
[Expr(arg, context).lll_node for arg in node.args],
context,
node.func,
is_external_call=True,
)
output_placeholder, output_size, returner = get_external_call_output(
sig, context)
sub = ["seq"]
if not output_size:
# if we do not expect return data, check that a contract exists at the target address
# we can omit this when we _do_ expect return data because we later check `returndatasize`
sub.append(["assert", ["extcodesize", contract_address]])
if context.is_constant() and sig.mutability not in ("view", "pure"):
# TODO this can probably go
raise StateAccessViolation(
f"May not call state modifying function '{method_name}' "
f"within {context.pp_constancy()}.",
node,
)
if context.is_constant() or sig.mutability in ("view", "pure"):
sub.append([
"assert",
[
"staticcall",
gas,
contract_address,
inargs,
inargsize,
output_placeholder,
output_size,
],
])
else:
sub.append([
"assert",
[
"call",
gas,
contract_address,
value,
inargs,
inargsize,
output_placeholder,
output_size,
],
])
if output_size:
# when return data is expected, revert when the length of `returndatasize` is insufficient
output_type = sig.output_type
if not has_dynamic_data(output_type):
static_output_size = get_static_size_of_type(output_type) * 32
sub.append(
["assert", ["gt", "returndatasize", static_output_size - 1]])
else:
if isinstance(output_type, ByteArrayLike):
types_list = (output_type, )
elif isinstance(output_type, TupleLike):
types_list = output_type.tuple_members()
else:
raise
dynamic_checks = []
static_offset = output_placeholder
static_output_size = 0
for typ in types_list:
# ensure length of bytes does not exceed max allowable length for type
if isinstance(typ, ByteArrayLike):
static_output_size += 32
# do not perform this check on calls to a JSON interface - we don't know
# for certain how long the expected data is
if not sig.is_from_json:
dynamic_checks.append([
"assert",
[
"lt",
[
"mload",
[
"add", ["mload", static_offset],
output_placeholder
],
],
typ.maxlen + 1,
],
])
static_offset += get_static_size_of_type(typ) * 32
static_output_size += get_static_size_of_type(typ) * 32
sub.append(
["assert", ["gt", "returndatasize", static_output_size - 1]])
sub.extend(dynamic_checks)
sub.extend(returner)
return LLLnode.from_list(sub,
typ=sig.output_type,
location="memory",
pos=getpos(node))
def from_FunctionDef(
cls,
node: vy_ast.FunctionDef,
is_interface: Optional[bool] = False,
) -> "ContractFunction":
"""
Generate a `ContractFunction` object from a `FunctionDef` node.
Arguments
---------
node : FunctionDef
Vyper ast node to generate the function definition from.
is_interface: bool, optional
Boolean indicating if the function definition is part of an interface.
Returns
-------
ContractFunction
"""
kwargs: Dict[str, Any] = {}
if is_interface:
# FunctionDef with stateMutability in body (Interface defintions)
if (len(node.body) == 1 and isinstance(node.body[0], vy_ast.Expr)
and isinstance(node.body[0].value, vy_ast.Name)
and StateMutability.is_valid_value(node.body[0].value.id)):
# Interfaces are always public
kwargs["function_visibility"] = FunctionVisibility.EXTERNAL
kwargs["state_mutability"] = StateMutability(
node.body[0].value.id)
elif len(node.body) == 1 and node.body[0].get("value.id") in (
"constant", "modifying"):
if node.body[0].value.id == "constant":
expected = "view or pure"
else:
expected = "payable or nonpayable"
raise StructureException(
f"State mutability should be set to {expected}",
node.body[0])
else:
raise StructureException(
"Body must only contain state mutability label",
node.body[0])
else:
# FunctionDef with decorators (normal functions)
for decorator in node.decorator_list:
if isinstance(decorator, vy_ast.Call):
if "nonreentrant" in kwargs:
raise StructureException(
"nonreentrant decorator is already set with key: "
f"{kwargs['nonreentrant']}",
node,
)
if decorator.get("func.id") != "nonreentrant":
raise StructureException("Decorator is not callable",
decorator)
if len(decorator.args) != 1 or not isinstance(
decorator.args[0], vy_ast.Str):
raise StructureException(
"@nonreentrant name must be given as a single string literal",
decorator,
)
kwargs["nonreentrant"] = decorator.args[0].value
elif isinstance(decorator, vy_ast.Name):
if FunctionVisibility.is_valid_value(decorator.id):
if "function_visibility" in kwargs:
raise FunctionDeclarationException(
f"Visibility is already set to: {kwargs['function_visibility']}",
node,
)
kwargs["function_visibility"] = FunctionVisibility(
decorator.id)
elif StateMutability.is_valid_value(decorator.id):
if "state_mutability" in kwargs:
raise FunctionDeclarationException(
f"Mutability is already set to: {kwargs['state_mutability']}",
node)
kwargs["state_mutability"] = StateMutability(
decorator.id)
else:
if decorator.id == "constant":
warnings.warn(
"'@constant' decorator has been removed (see VIP2040). "
"Use `@view` instead.",
DeprecationWarning,
)
raise FunctionDeclarationException(
f"Unknown decorator: {decorator.id}", decorator)
else:
raise StructureException("Bad decorator syntax", decorator)
if "function_visibility" not in kwargs:
raise FunctionDeclarationException(
f"Visibility must be set to one of: {', '.join(FunctionVisibility.values())}",
node)
if "state_mutability" not in kwargs:
# Assume nonpayable if not set at all (cannot accept Ether, but can modify state)
kwargs["state_mutability"] = StateMutability.NONPAYABLE
# call arguments
arg_count: Union[Tuple[int, int], int] = len(node.args.args)
if node.args.defaults:
arg_count = (
len(node.args.args) - len(node.args.defaults),
len(node.args.args),
)
arguments = OrderedDict()
defaults = [None] * (len(node.args.args) -
len(node.args.defaults)) + node.args.defaults
namespace = get_namespace()
for arg, value in zip(node.args.args, defaults):
if arg.arg in ("gas", "value"):
raise ArgumentException(
f"Cannot use '{arg.arg}' as a variable name in a function input",
arg,
)
if arg.arg in arguments:
raise ArgumentException(
f"Function contains multiple inputs named {arg.arg}", arg)
if arg.arg in namespace["self"].members:
raise NamespaceCollision(
"Name shadows an existing storage-scoped value", arg)
if arg.arg in namespace:
raise NamespaceCollision(arg.arg, arg)
if arg.annotation is None:
raise ArgumentException(
f"Function argument '{arg.arg}' is missing a type", arg)
type_definition = get_type_from_annotation(
arg.annotation,
location=DataLocation.CALLDATA,
is_immutable=True)
if isinstance(
type_definition,
StructDefinition) and type_definition.is_dynamic_size:
# this is a temporary restriction and should be removed once support for dynamically
# sized structs is implemented - https://github.com/vyperlang/vyper/issues/2190
raise ArgumentException(
"Struct with dynamically sized data cannot be used as a function input",
arg)
if value is not None:
if not check_constant(value):
raise StateAccessViolation(
"Value must be literal or environment variable", value)
validate_expected_type(value, type_definition)
arguments[arg.arg] = type_definition
# return types
if node.returns is None:
return_type = None
elif isinstance(node.returns,
(vy_ast.Name, vy_ast.Call, vy_ast.Subscript)):
return_type = get_type_from_annotation(
node.returns, location=DataLocation.MEMORY)
elif isinstance(node.returns, vy_ast.Tuple):
tuple_types: Tuple = ()
for n in node.returns.elements:
tuple_types += (get_type_from_annotation(
n, location=DataLocation.MEMORY), )
return_type = TupleDefinition(tuple_types)
else:
raise InvalidType(
"Function return value must be a type name or tuple",
node.returns)
return cls(node.name, arguments, arg_count, return_type, **kwargs)
def check_is_not_constant(self, err, expr):
if self.is_constant():
raise StateAccessViolation(
f"Cannot {err} from {self.pp_constancy()}", expr)