slither.utils.encoding

  1from typing import Union
  2
  3from slither.core import variables
  4from slither.core.declarations import (
  5    SolidityVariable,
  6    SolidityVariableComposed,
  7    Structure,
  8    Enum,
  9    Contract,
 10)
 11from slither.core import solidity_types
 12from slither.slithir import operations
 13from slither.slithir import variables as SlitherIRVariable
 14
 15
 16# pylint: disable=too-many-branches
 17def ntype(_type: Union[solidity_types.Type, str]) -> str:
 18    if isinstance(_type, solidity_types.ElementaryType):
 19        _type = str(_type)
 20    elif isinstance(_type, solidity_types.ArrayType):
 21        if isinstance(_type.type, solidity_types.ElementaryType):
 22            _type = str(_type)
 23        else:
 24            _type = "user_defined_array"
 25    elif isinstance(_type, Structure):
 26        _type = str(_type)
 27    elif isinstance(_type, Enum):
 28        _type = str(_type)
 29    elif isinstance(_type, solidity_types.MappingType):
 30        _type = str(_type)
 31    elif isinstance(_type, solidity_types.UserDefinedType):
 32        if isinstance(_type.type, Contract):
 33            _type = f"contract({_type.type.name})"
 34        elif isinstance(_type.type, Structure):
 35            _type = f"struct({_type.type.name})"
 36        elif isinstance(_type.type, Enum):
 37            _type = f"enum({_type.type.name})"
 38    else:
 39        _type = str(_type)
 40
 41    _type = _type.replace(" memory", "")
 42    _type = _type.replace(" storage ref", "")
 43
 44    if "struct" in _type:
 45        return "struct"
 46    if "enum" in _type:
 47        return "enum"
 48    if "tuple" in _type:
 49        return "tuple"
 50    if "contract" in _type:
 51        return "contract"
 52    if "mapping" in _type:
 53        return "mapping"
 54    return _type.replace(" ", "_")
 55
 56
 57# pylint: disable=too-many-branches
 58def encode_var_for_compare(var: Union[variables.Variable, SolidityVariable]) -> str:
 59
 60    # variables
 61    if isinstance(var, SlitherIRVariable.Constant):
 62        return f"constant({ntype(var.type)},{var.value})"
 63    if isinstance(var, SolidityVariableComposed):
 64        return f"solidity_variable_composed({var.name})"
 65    if isinstance(var, SolidityVariable):
 66        return f"solidity_variable{var.name}"
 67    if isinstance(var, SlitherIRVariable.TemporaryVariable):
 68        return "temporary_variable"
 69    if isinstance(var, SlitherIRVariable.ReferenceVariable):
 70        return f"reference({ntype(var.type)})"
 71    if isinstance(var, variables.LocalVariable):
 72        return f"local_solc_variable({ntype(var.type)},{var.location})"
 73    if isinstance(var, variables.StateVariable):
 74        if var.is_stored:
 75            try:
 76                slot, _ = var.contract.compilation_unit.storage_layout_of(var.contract, var)
 77            except KeyError:
 78                slot = var.name
 79        else:
 80            slot = var.name
 81        return f"state_solc_variable({ntype(var.type)},{slot})"
 82    if isinstance(var, variables.LocalVariableInitFromTuple):
 83        return "local_variable_init_tuple"
 84    if isinstance(var, SlitherIRVariable.TupleVariable):
 85        return "tuple_variable"
 86
 87    # default
 88    return ""
 89
 90
 91# pylint: disable=too-many-branches
 92def encode_ir_for_upgradeability_compare(ir: operations.Operation) -> str:
 93    # operations
 94    if isinstance(ir, operations.Assignment):
 95        return f"({encode_var_for_compare(ir.lvalue)}):=({encode_var_for_compare(ir.rvalue)})"
 96    if isinstance(ir, operations.Index):
 97        return f"index({ntype(ir.variable_right.type)})"
 98    if isinstance(ir, operations.Member):
 99        return "member"  # .format(ntype(ir._type))
100    if isinstance(ir, operations.Length):
101        return "length"
102    if isinstance(ir, operations.Binary):
103        return f"binary({encode_var_for_compare(ir.variable_left)}{ir.type}{encode_var_for_compare(ir.variable_right)})"
104    if isinstance(ir, operations.Unary):
105        return f"unary({str(ir.type)})"
106    if isinstance(ir, operations.Condition):
107        return f"condition({encode_var_for_compare(ir.value)})"
108    if isinstance(ir, operations.NewStructure):
109        return "new_structure"
110    if isinstance(ir, operations.NewContract):
111        return "new_contract"
112    if isinstance(ir, operations.NewArray):
113        return f"new_array({ntype(ir.array_type)})"
114    if isinstance(ir, operations.NewElementaryType):
115        return f"new_elementary({ntype(ir.type)})"
116    if isinstance(ir, operations.Delete):
117        return f"delete({encode_var_for_compare(ir.lvalue)},{encode_var_for_compare(ir.variable)})"
118    if isinstance(ir, operations.SolidityCall):
119        return f"solidity_call({ir.function.full_name})"
120    if isinstance(ir, operations.InternalCall):
121        return f"internal_call({ntype(ir.type_call)})"
122    if isinstance(ir, operations.EventCall):  # is this useful?
123        return "event"
124    if isinstance(ir, operations.LibraryCall):
125        return "library_call"
126    if isinstance(ir, operations.InternalDynamicCall):
127        return "internal_dynamic_call"
128    if isinstance(ir, operations.HighLevelCall):  # TODO: improve
129        return "high_level_call"
130    if isinstance(ir, operations.LowLevelCall):  # TODO: improve
131        return "low_level_call"
132    if isinstance(ir, operations.TypeConversion):
133        return f"type_conversion({ntype(ir.type)})"
134    if isinstance(ir, operations.Return):  # this can be improved using values
135        return "return"  # .format(ntype(ir.type))
136    if isinstance(ir, operations.Transfer):
137        return f"transfer({encode_var_for_compare(ir.call_value)})"
138    if isinstance(ir, operations.Send):
139        return f"send({encode_var_for_compare(ir.call_value)})"
140    if isinstance(ir, operations.Unpack):  # TODO: improve
141        return "unpack"
142    if isinstance(ir, operations.InitArray):  # TODO: improve
143        return "init_array"
144
145    # default
146    return ""
147
148
149def encode_ir_for_halstead(ir: operations.Operation) -> str:
150    # operations
151    if isinstance(ir, operations.Assignment):
152        return "assignment"
153    if isinstance(ir, operations.Index):
154        return "index"
155    if isinstance(ir, operations.Member):
156        return "member"  # .format(ntype(ir._type))
157    if isinstance(ir, operations.Length):
158        return "length"
159    if isinstance(ir, operations.Binary):
160        return f"binary({str(ir.type)})"
161    if isinstance(ir, operations.Unary):
162        return f"unary({str(ir.type)})"
163    if isinstance(ir, operations.Condition):
164        return f"condition({encode_var_for_compare(ir.value)})"
165    if isinstance(ir, operations.NewStructure):
166        return "new_structure"
167    if isinstance(ir, operations.NewContract):
168        return "new_contract"
169    if isinstance(ir, operations.NewArray):
170        return f"new_array({ntype(ir.array_type)})"
171    if isinstance(ir, operations.NewElementaryType):
172        return f"new_elementary({ntype(ir.type)})"
173    if isinstance(ir, operations.Delete):
174        return "delete"
175    if isinstance(ir, operations.SolidityCall):
176        return f"solidity_call({ir.function.full_name})"
177    if isinstance(ir, operations.InternalCall):
178        return f"internal_call({ntype(ir.type_call)})"
179    if isinstance(ir, operations.EventCall):  # is this useful?
180        return "event"
181    if isinstance(ir, operations.LibraryCall):
182        return "library_call"
183    if isinstance(ir, operations.InternalDynamicCall):
184        return "internal_dynamic_call"
185    if isinstance(ir, operations.HighLevelCall):  # TODO: improve
186        return "high_level_call"
187    if isinstance(ir, operations.LowLevelCall):  # TODO: improve
188        return "low_level_call"
189    if isinstance(ir, operations.TypeConversion):
190        return f"type_conversion({ntype(ir.type)})"
191    if isinstance(ir, operations.Return):  # this can be improved using values
192        return "return"  # .format(ntype(ir.type))
193    if isinstance(ir, operations.Transfer):
194        return "transfer"
195    if isinstance(ir, operations.Send):
196        return "send"
197    if isinstance(ir, operations.Unpack):  # TODO: improve
198        return "unpack"
199    if isinstance(ir, operations.InitArray):  # TODO: improve
200        return "init_array"
201    # default
202    raise NotImplementedError(f"encode_ir_for_halstead: {ir}")