def parse_assert(self):
with self.context.assertion_scope():
test_expr = Expr.parse_value_expr(self.stmt.test, self.context)
if not self.is_bool_expr(test_expr):
raise TypeMismatchException('Only boolean expressions allowed',
self.stmt.test)
if self.stmt.msg:
if not isinstance(self.stmt.msg, ast.Str):
raise StructureException(
'Reason parameter of assert needs to be a literal string.',
self.stmt.msg)
if len(self.stmt.msg.s.strip()) == 0:
raise StructureException('Empty reason string not allowed.',
self.stmt)
reason_str = self.stmt.msg.s.strip()
sig_placeholder = self.context.new_placeholder(BaseType(32))
arg_placeholder = self.context.new_placeholder(BaseType(32))
reason_str_type = ByteArrayType(len(reason_str))
placeholder_bytes = Expr(self.stmt.msg, self.context).lll_node
method_id = fourbytes_to_int(sha3(b"Error(string)")[:4])
assert_reason = \
['seq',
['mstore', sig_placeholder, method_id],
['mstore', arg_placeholder, 32],
placeholder_bytes,
['assert_reason', test_expr, int(sig_placeholder + 28), int(4 + 32 + get_size_of_type(reason_str_type) * 32)]]
return LLLnode.from_list(assert_reason,
typ=None,
pos=getpos(self.stmt))
else:
return LLLnode.from_list(['assert', test_expr],
typ=None,
pos=getpos(self.stmt))
def _sha3(expr, args, kwargs, context):
sub = args[0]
# Can hash literals
if isinstance(sub, bytes):
return LLLnode.from_list(bytes_to_int(sha3(sub)), typ=BaseType('bytes32'), pos=getpos(expr))
# Can hash bytes32 objects
if is_base_type(sub.typ, 'bytes32'):
return LLLnode.from_list(
['seq', ['mstore', MemoryPositions.FREE_VAR_SPACE, sub], ['sha3', MemoryPositions.FREE_VAR_SPACE, 32]], typ=BaseType('bytes32'),
pos=getpos(expr)
)
# Copy the data to an in-memory array
if sub.location == "memory":
# If we are hashing a value in memory, no need to copy it, just hash in-place
return LLLnode.from_list(
['with', '_sub', sub, ['sha3', ['add', '_sub', 32], ['mload', '_sub']]], typ=BaseType('bytes32'),
pos=getpos(expr)
)
elif sub.location == "storage":
lengetter = LLLnode.from_list(['sload', ['sha3_32', '_sub']], typ=BaseType('int128'))
else:
# This should never happen, but just left here for future compiler-writers.
raise Exception("Unsupported location: %s" % sub.location) # pragma: no test
placeholder = context.new_placeholder(sub.typ)
placeholder_node = LLLnode.from_list(placeholder, typ=sub.typ, location='memory')
copier = make_byte_array_copier(placeholder_node, LLLnode.from_list('_sub', typ=sub.typ, location=sub.location))
return LLLnode.from_list(
['with', '_sub', sub, ['seq', copier, ['sha3', ['add', placeholder, 32], lengetter]]], typ=BaseType('bytes32'),
pos=getpos(expr)
)
def _assert_reason(self, test_expr, msg):
if not isinstance(msg, ast.Str):
raise StructureException(
'Reason parameter of assert needs to be a literal string.',
msg)
if len(msg.s.strip()) == 0:
raise StructureException('Empty reason string not allowed.',
self.stmt)
reason_str = msg.s.strip()
sig_placeholder = self.context.new_placeholder(BaseType(32))
arg_placeholder = self.context.new_placeholder(BaseType(32))
reason_str_type = ByteArrayType(len(reason_str))
placeholder_bytes = Expr(msg, self.context).lll_node
method_id = fourbytes_to_int(sha3(b"Error(string)")[:4])
assert_reason = [
'seq',
['mstore', sig_placeholder, method_id],
['mstore', arg_placeholder, 32],
placeholder_bytes,
[
'assert_reason',
test_expr,
int(sig_placeholder + 28),
int(4 + 32 + get_size_of_type(reason_str_type) * 32),
],
]
return LLLnode.from_list(assert_reason,
typ=None,
pos=getpos(self.stmt))
def parse_assert(self):
if self.stmt.msg:
if len(self.stmt.msg.s.strip()) == 0:
raise StructureException('Empty reason string not allowed.',
self.stmt)
reason_str = self.stmt.msg.s.strip()
sig_placeholder = self.context.new_placeholder(BaseType(32))
arg_placeholder = self.context.new_placeholder(BaseType(32))
reason_str_type = ByteArrayType(len(reason_str))
placeholder_bytes = Expr(self.stmt.msg, self.context).lll_node
method_id = fourbytes_to_int(sha3(b"Error(string)")[:4])
assert_reason = \
['seq',
['mstore', sig_placeholder, method_id],
['mstore', arg_placeholder, 32],
placeholder_bytes,
['assert_reason', Expr.parse_value_expr(self.stmt.test, self.context), int(sig_placeholder + 28), int(4 + 32 + get_size_of_type(reason_str_type) * 32)]]
return LLLnode.from_list(assert_reason,
typ=None,
pos=getpos(self.stmt))
else:
return LLLnode.from_list([
'assert',
Expr.parse_value_expr(self.stmt.test, self.context)
],
typ=None,
pos=getpos(self.stmt))
def from_declaration(cls, code, custom_units=None):
name = code.target.id
pos = 0
if not is_varname_valid(name, custom_units=custom_units):
raise EventDeclarationException("Event name invalid: " + name)
# Determine the arguments, expects something of the form def foo(arg1: num, arg2: num ...
args = []
indexed_list = []
topics_count = 1
if code.annotation.args:
keys = code.annotation.args[0].keys
values = code.annotation.args[0].values
for i in range(len(keys)):
typ = values[i]
arg = keys[i].id
is_indexed = False
# Check to see if argument is a topic
if isinstance(typ, ast.Call) and typ.func.id == 'indexed':
typ = values[i].args[0]
indexed_list.append(True)
topics_count += 1
is_indexed = True
else:
indexed_list.append(False)
if isinstance(typ, ast.Subscript) and getattr(
typ.value, 'id', None
) == 'bytes' and typ.slice.value.n > 32 and is_indexed:
raise EventDeclarationException(
"Indexed arguments are limited to 32 bytes")
if topics_count > 4:
raise EventDeclarationException(
"Maximum of 3 topics {} given".format(topics_count -
1), arg)
if not isinstance(arg, str):
raise VariableDeclarationException("Argument name invalid",
arg)
if not typ:
raise InvalidTypeException("Argument must have type", arg)
if not is_varname_valid(arg, custom_units):
raise VariableDeclarationException(
"Argument name invalid or reserved: " + arg, arg)
if arg in (x.name for x in args):
raise VariableDeclarationException(
"Duplicate function argument name: " + arg, arg)
parsed_type = parse_type(typ, None, custom_units=custom_units)
args.append(VariableRecord(arg, pos, parsed_type, False))
if isinstance(parsed_type, ByteArrayType):
pos += ceil32(typ.slice.value.n)
else:
pos += get_size_of_type(parsed_type) * 32
sig = name + '(' + ','.join([
canonicalize_type(arg.typ, indexed_list[pos])
for pos, arg in enumerate(args)
]) + ')' # noqa F812
event_id = bytes_to_int(sha3(bytes(sig, 'utf-8')))
return cls(name, args, indexed_list, event_id, sig)
def method_id(expr, args, kwargs, context):
if b' ' in args[0]:
raise TypeMismatchException('Invalid function signature no spaces allowed.')
method_id = fourbytes_to_int(sha3(args[0])[:4])
if args[1] == 'bytes32':
return LLLnode(method_id, typ=BaseType('bytes32'), pos=getpos(expr))
elif args[1] == 'bytes[4]':
placeholder = LLLnode.from_list(context.new_placeholder(ByteArrayType(4)))
return LLLnode.from_list(
['seq',
['mstore', ['add', placeholder, 4], method_id],
['mstore', placeholder, 4], placeholder],
typ=ByteArrayType(4), location='memory', pos=getpos(expr))
else:
raise StructureException('Can only produce bytes32 or bytes[4] as outputs')
def from_definition(cls,
code,
sigs=None,
custom_units=None,
contract_def=False,
constant=False):
name = code.name
pos = 0
if not is_varname_valid(name, custom_units=custom_units):
raise FunctionDeclarationException("Function name invalid: " +
name)
# Determine the arguments, expects something of the form def foo(arg1: int128, arg2: int128 ...
args = []
for arg in code.args.args:
typ = arg.annotation
if not typ:
raise InvalidTypeException("Argument must have type", arg)
if not is_varname_valid(arg.arg, custom_units=custom_units):
raise FunctionDeclarationException(
"Argument name invalid or reserved: " + arg.arg, arg)
if arg.arg in (x.name for x in args):
raise FunctionDeclarationException(
"Duplicate function argument name: " + arg.arg, arg)
parsed_type = parse_type(typ,
None,
sigs,
custom_units=custom_units)
args.append(VariableRecord(arg.arg, pos, parsed_type, False))
if isinstance(parsed_type, ByteArrayType):
pos += 32
else:
pos += get_size_of_type(parsed_type) * 32
# Apply decorators
const, payable, private, public = False, False, False, False
for dec in code.decorator_list:
if isinstance(dec, ast.Name) and dec.id == "constant":
const = True
elif isinstance(dec, ast.Name) and dec.id == "payable":
payable = True
elif isinstance(dec, ast.Name) and dec.id == "private":
private = True
elif isinstance(dec, ast.Name) and dec.id == "public":
public = True
else:
raise StructureException("Bad decorator", dec)
if public and private:
raise StructureException(
"Cannot use public and private decorators on the same function: {}"
.format(name))
if payable and const:
raise StructureException(
"Function {} cannot be both constant and payable.".format(
name))
if payable and private:
raise StructureException(
"Function {} cannot be both private and payable.".format(name))
if (not public and not private) and not contract_def:
raise StructureException(
"Function visibility must be declared (@public or @private)",
code)
if constant:
const = True
# Determine the return type and whether or not it's constant. Expects something
# of the form:
# def foo(): ...
# def foo() -> int128: ...
# If there is no return type, ie. it's of the form def foo(): ...
# and NOT def foo() -> type: ..., then it's null
if not code.returns:
output_type = None
elif isinstance(
code.returns,
(ast.Name, ast.Compare, ast.Subscript, ast.Call, ast.Tuple)):
output_type = parse_type(code.returns,
None,
sigs,
custom_units=custom_units)
else:
raise InvalidTypeException(
"Output type invalid or unsupported: %r" %
parse_type(code.returns, None),
code.returns,
)
# Output type must be canonicalizable
if output_type is not None:
assert isinstance(output_type,
TupleType) or canonicalize_type(output_type)
# Get the canonical function signature
sig = cls.get_full_sig(name, code.args.args, sigs, custom_units)
# Take the first 4 bytes of the hash of the sig to get the method ID
method_id = fourbytes_to_int(sha3(bytes(sig, 'utf-8'))[:4])
return cls(name, args, output_type, const, payable, private, sig,
method_id, custom_units)
def method_id(expr, args, kwargs, context):
method_id = fourbytes_to_int(sha3(args[0])[:4])
return LLLnode(method_id, typ=BaseType('method_id'), pos=getpos(expr))
def from_definition(cls,
code,
sigs=None,
custom_units=None,
custom_structs=None,
contract_def=False,
constants=None,
constant=False):
if not custom_structs:
custom_structs = {}
name = code.name
mem_pos = 0
valid_name, msg = is_varname_valid(name, custom_units, custom_structs,
constants)
if not valid_name and (not name.lower() in function_whitelist):
raise FunctionDeclarationException("Function name invalid. " + msg,
code)
# Validate default values.
for default_value in getattr(code.args, 'defaults', []):
if not isinstance(default_value,
(ast.Num, ast.Str, ast.Bytes, ast.List)):
raise FunctionDeclarationException(
"Default parameter values have to be literals.")
# Determine the arguments, expects something of the form def foo(arg1:
# int128, arg2: int128 ...
args = []
for arg in code.args.args:
# Each arg needs a type specified.
typ = arg.annotation
if not typ:
raise InvalidTypeException("Argument must have type", arg)
# Validate arg name.
check_valid_varname(
arg.arg,
custom_units,
custom_structs,
constants,
arg,
"Argument name invalid or reserved. ",
FunctionDeclarationException,
)
# Check for duplicate arg name.
if arg.arg in (x.name for x in args):
raise FunctionDeclarationException(
"Duplicate function argument name: " + arg.arg,
arg,
)
parsed_type = parse_type(
typ,
None,
sigs,
custom_units=custom_units,
custom_structs=custom_structs,
constants=constants,
)
args.append(
VariableRecord(
arg.arg,
mem_pos,
parsed_type,
False,
defined_at=getpos(arg),
))
if isinstance(parsed_type, ByteArrayLike):
mem_pos += 32
else:
mem_pos += get_size_of_type(parsed_type) * 32
# Apply decorators
const, payable, private, public, nonreentrant_key = False, False, False, False, ''
for dec in code.decorator_list:
if isinstance(dec, ast.Name) and dec.id == "constant":
const = True
elif isinstance(dec, ast.Name) and dec.id == "payable":
payable = True
elif isinstance(dec, ast.Name) and dec.id == "private":
private = True
elif isinstance(dec, ast.Name) and dec.id == "public":
public = True
elif isinstance(dec, ast.Call) and dec.func.id == "nonreentrant":
if dec.args and len(dec.args) == 1 and isinstance(
dec.args[0], ast.Str) and dec.args[0].s: # noqa: E501
nonreentrant_key = dec.args[0].s
else:
raise StructureException(
"@nonreentrant decorator requires a non-empty string to use as a key.",
dec)
else:
raise StructureException("Bad decorator", dec)
if public and private:
raise StructureException(
"Cannot use public and private decorators on the same function: {}"
.format(name))
if payable and const:
raise StructureException(
"Function {} cannot be both constant and payable.".format(
name))
if payable and private:
raise StructureException(
"Function {} cannot be both private and payable.".format(name))
if (not public and not private) and not contract_def:
raise StructureException(
"Function visibility must be declared (@public or @private)",
code,
)
if constant and nonreentrant_key:
raise StructureException(
"@nonreentrant makes no sense on a @constant function.", code)
if constant:
const = True
# Determine the return type and whether or not it's constant. Expects something
# of the form:
# def foo(): ...
# def foo() -> int128: ...
# If there is no return type, ie. it's of the form def foo(): ...
# and NOT def foo() -> type: ..., then it's null
if not code.returns:
output_type = None
elif isinstance(
code.returns,
(ast.Name, ast.Compare, ast.Subscript, ast.Call, ast.Tuple)):
output_type = parse_type(
code.returns,
None,
sigs,
custom_units=custom_units,
custom_structs=custom_structs,
constants=constants,
)
else:
raise InvalidTypeException(
"Output type invalid or unsupported: %r" %
parse_type(code.returns, None),
code.returns,
)
# Output type must be canonicalizable
if output_type is not None:
assert isinstance(output_type,
TupleType) or canonicalize_type(output_type)
# Get the canonical function signature
sig = cls.get_full_sig(name, code.args.args, sigs, custom_units,
custom_structs, constants)
# Take the first 4 bytes of the hash of the sig to get the method ID
method_id = fourbytes_to_int(sha3(bytes(sig, 'utf-8'))[:4])
return cls(name, args, output_type, const, payable, private,
nonreentrant_key, sig, method_id, custom_units, code)
