certora-cli-beta-mirror 7.28.0__py3-none-any.whl → 8.5.0__py3-none-any.whl

certora_cli/CertoraProver/Compiler/CompilerCollectorFactory.py

@@ -25,8 +25,9 @@ from CertoraProver.Compiler.CompilerCollector import CompilerLang, CompilerColle
 from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol, CompilerLangSol
 from CertoraProver.Compiler.CompilerCollectorYul import CompilerLangYul, CompilerCollectorYul
 from CertoraProver.Compiler.CompilerCollectorVy import CompilerCollectorVy, CompilerLangVy
-from Shared.certoraUtils import match_path_to_mapping_key, remove_file, get_certora_config_dir
+from Shared.certoraUtils import remove_file, get_certora_config_dir
 from CertoraProver.certoraContextClass import CertoraContext
+import CertoraProver.certoraContext as Ctx
 
 # logger for running the Solidity compiler and reporting any errors it emits
 compiler_logger = logging.getLogger("compiler")
@@ -42,10 +43,16 @@ def get_relevant_compiler(contract_file_path: Path, context: CertoraContext) ->
 
     if contract_file_path.is_absolute():
         contract_file_path = Path(os.path.relpath(contract_file_path, Path.cwd()))
+
+    # If the contract file is in the sources directory, we want to use the relative path from the "cwd" in the source tree.
+    if Util.get_certora_sources_dir() in contract_file_path.parents:
+        cwd_in_source = Util.get_certora_sources_dir() / context.cwd_rel_in_sources
+        contract_file_path = Path(os.path.relpath(contract_file_path, cwd_in_source))
+
     if context.compiler_map:
-        match = match_path_to_mapping_key(contract_file_path, context.compiler_map)
+        match = Ctx.get_map_attribute_value(context, contract_file_path, 'compiler')
         if match:
-            return match
+            return str(match)
         else:
             raise RuntimeError(f'cannot match compiler to {contract_file_path} from compiler_map')
 

certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py

@@ -556,43 +556,78 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         else:
             raise Exception(f"Unexpected ast_node {ast_node}, cannot evaluate constant")
 
+    @staticmethod
+    def subscript_node(ast_node: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        ty = ast_node.get("ast_type")
+        # pre-vyper 0.4.0, look deeper within
+        if ty == "Index":
+            nested = ast_node.get("value")
+            if nested is None or not isinstance(nested, dict):
+                return None
+            return nested
+        else:
+            return ast_node
+
+    @staticmethod
+    def int_subscript(ast_node: Dict[str, Any], named_constants: Dict[str, int]) -> Optional[int]:
+        node = CompilerLangVy.subscript_node(ast_node)
+        if node is None:
+            return None
+
+        if "id" in node and node["id"] in named_constants:
+            return named_constants[node["id"]]
+        elif node.get("ast_type") == "Int":
+            return node.get("value")
+        else:
+            return None
+
+    @staticmethod
+    def get_tuple_elements(ast_node: Dict[str, Any]) -> List[Dict[str, Any]]:
+        node = CompilerLangVy.subscript_node(ast_node)
+        if node is None or node.get("ast_type") != "Tuple":
+            raise Exception("Couldn't get tuple elements from ast node")
+        return node["elements"]
+
     @staticmethod
     def extract_type_from_subscript_node(ast_subscript_node: Dict[str, Any],
                                          named_constants: Dict[str, int]) -> VyperType:
         value_id = ast_subscript_node['value'].get('id', None)
         if value_id == 'String':
-            max_bytes = ast_subscript_node['slice']['value']['value']
+            max_bytes = CompilerLangVy.int_subscript(ast_subscript_node['slice'], named_constants)
+            if max_bytes is None:
+                raise Exception("Failed to find max length for string type declaration")
             return CompilerLangVy.VyperTypeString(max_bytes)
         elif value_id == 'Bytes':
-            max_bytes = ast_subscript_node['slice']['value']['value']
+            max_bytes = CompilerLangVy.int_subscript(ast_subscript_node['slice'], named_constants)
+            if max_bytes is None:
+                raise Exception("Failed to find max length for bytes type declaration")
             return CompilerLangVy.VyperTypeBytes(max_bytes)
         elif value_id == 'DynArray':
-            elem_type = CompilerLangVy.extract_type_from_type_annotation_node(
-                ast_subscript_node['slice']['value']['elements'][0], named_constants)
-            max_elements = CompilerLangVy.extract_constant(ast_subscript_node['slice']['value']['elements'][1],
-                                                           named_constants)
+            tup_elems = CompilerLangVy.get_tuple_elements(ast_subscript_node["slice"])
+            elem_type = CompilerLangVy.extract_type_from_type_annotation_node(tup_elems[0], named_constants)
+            max_elements = CompilerLangVy.extract_constant(tup_elems[1], named_constants)
             return CompilerLangVy.VyperTypeDynArray(elem_type, max_elements)
         elif value_id == 'HashMap':
-            elements_node = ast_subscript_node['slice']['value']['elements']
+            elements_node = CompilerLangVy.get_tuple_elements(ast_subscript_node['slice'])
             key_type = CompilerLangVy.extract_type_from_type_annotation_node(elements_node[0], named_constants)
             value_type = CompilerLangVy.extract_type_from_type_annotation_node(elements_node[1], named_constants)
             return CompilerLangVy.VyperTypeHashMap(key_type, value_type)
         else:  # StaticArray key_type[size]
             key_type = CompilerLangVy.extract_type_from_type_annotation_node(ast_subscript_node['value'],
                                                                              named_constants)
-            max_elements_node = ast_subscript_node['slice']['value']
-            if 'id' in max_elements_node and max_elements_node['id'] in named_constants:
-                return CompilerLangVy.VyperTypeStaticArray(key_type, named_constants[max_elements_node['id']])
+            max_elem_value = CompilerLangVy.int_subscript(ast_subscript_node['slice'], named_constants)
+            if max_elem_value is not None:
+                return CompilerLangVy.VyperTypeStaticArray(key_type, max_elem_value)
             else:
                 # this is very specific to curve code which has uint256[CONST/2] static array declaration.
+                max_elements_node = CompilerLangVy.subscript_node(ast_subscript_node["slice"])
+                if max_elements_node is None:
+                    raise Exception("Couldn't find subscript node for array type")
                 if 'ast_type' in max_elements_node:
                     if max_elements_node['ast_type'] == 'BinOp' or max_elements_node['ast_type'] in ('Int', 'Name'):
                         # good chance this will succeed
                         static_array_len = CompilerLangVy.extract_constant(max_elements_node, named_constants)
                         return CompilerLangVy.VyperTypeStaticArray(key_type, static_array_len)
-                elif 'value' in max_elements_node:
-                    return CompilerLangVy.VyperTypeStaticArray(key_type, max_elements_node['value'])
-
                 raise Exception(
                     f"Don't know how to deal with vyper static array declaration with length {max_elements_node}")
 
@@ -624,7 +659,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
     @staticmethod
     def extract_type_from_enum_def(ast_enumdef_node: Dict[str, Any]) -> VyperType:
-        fields = [n['target']['id'] for n in ast_enumdef_node['body']]
+        fields = [n['target']['id'] if "target" in n else n["value"]["id"] for n in ast_enumdef_node['body']]
         return CompilerLangVy.VyperTypeEnum(ast_enumdef_node['name'], fields)
 
     @staticmethod
@@ -1238,7 +1273,7 @@ class Collector:
             self._collect_const(v)
 
         # Extract and resolve types
-        type_asts = {'EnumDef', 'StructDef', 'InterfaceDef', 'Import', 'Import', 'ImportFrom'}
+        type_asts = {'EnumDef', 'StructDef', 'InterfaceDef', 'Import', 'Import', 'ImportFrom', 'FlagDef'}
         types = [e for e in module_node['body'] if e['ast_type'] in type_asts]
         for t in types:
             self._collect_type_decl(t)
@@ -1265,7 +1300,7 @@ class Collector:
 
     def _collect_type_decl(self, type_decl_node: Dict[str, Any]) -> None:
         """Update self.types to add type definition from `type_decl_node`.  Expects self.consts to be initialized"""
-        if type_decl_node['ast_type'] == 'EnumDef':
+        if type_decl_node['ast_type'] in ('EnumDef', 'FlagDef'):
             vy_type = CompilerLangVy.extract_type_from_enum_def(type_decl_node)
         elif type_decl_node['ast_type'] == 'StructDef':
             vy_type = CompilerLangVy.extract_type_from_struct_def(type_decl_node, self.consts)

certora_cli/CertoraProver/Compiler/CompilerCollectorYul.py

@@ -104,14 +104,17 @@ class CompilerLangYul(CompilerLangSol, metaclass=Singleton):
                         notpayable=notpayable,
                         fromLib=False,
                         isConstructor=False,
+                        is_free_func=False,
                         stateMutability=state_mutability,
                         visibility=visibility,
                         implemented=True,
                         overrides=False,
+                        virtual=False,
                         contractName=contract_name,
                         source_bytes=None,
                         ast_id=None,
                         original_file=None,
+                        location=None,
                         body_location=None,
                     )
                     funcs.append(func)

certora_cli/CertoraProver/castingInstrumenter.py

@@ -0,0 +1,192 @@
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+from dataclasses import dataclass
+from typing import Dict, Any, Optional, Generator
+
+from CertoraProver.Compiler.CompilerCollectorSol import CompilerCollectorSol
+from CertoraProver.certoraBuildDataClasses import SDC, Instrumentation, Replace
+from Shared import certoraUtils as Util
+
+
+@dataclass
+class IntType:
+    is_signed: bool
+    bitwidth: int
+
+    def encode(self) -> Optional[int]:
+        """
+        Encodes into a 9 bit number: lowest bit is on if [IntType] is true, and upper 8 bits are the width.
+        returns none if width is out of bounds.
+        """
+        if self.bitwidth <= 0 or self.bitwidth > 256:
+            return None
+        return self.bitwidth * 2 + int(self.is_signed)
+
+
+def parse_int_type(type_string: str) -> Optional[IntType]:
+    """
+    Parse an integer type string of the form 'int<bitwidth>' or 'uint<bitwidth>'.
+    Returns IntType or None if the string doesn't match the pattern.
+    """
+    if type_string == "int":
+        return IntType(True, 256)
+    elif type_string == "uint":
+        return IntType(False, 256)
+    elif type_string.startswith("int"):
+        is_signed = True
+        bitwidth_str = type_string[3:]
+    elif type_string.startswith("uint"):
+        is_signed = False
+        bitwidth_str = type_string[4:]
+    else:
+        return None
+
+    try:
+        bitwidth = int(bitwidth_str)
+        return IntType(is_signed, bitwidth)
+    except ValueError:
+        return None
+
+
+def is_int_type(type_string: str) -> bool:
+    return parse_int_type(type_string) is not None
+
+
+def encode_type(type_string: str) -> int:
+    int_type = parse_int_type(type_string)
+    if int_type is None:
+        raise Exception(f"Invalid type string: {type_string}")
+    encoded = int_type.encode()
+    if encoded is None:
+        raise Exception(f"Invalid type string: {type_string}")
+    return encoded
+
+
+@dataclass
+class CastInfo:
+    arg_type_str: str
+    res_type_str: str
+    expr_id: int
+
+
+def find_casts(ast: Dict[int, Any]) -> list[CastInfo]:
+    """
+    Search all nodes that are in functions for kind "typeConversion" with one argument.
+    Returns a list of CastInfo instances.
+    """
+    conversions = []
+    function_nodes = [node for node in ast.values() if node.get('nodeType') == 'FunctionDefinition']
+
+    for func in function_nodes:
+        for node in iter_all_nodes(func):
+            if isinstance(node, dict) and node.get("kind") == "typeConversion":
+                arguments = node.get("arguments", [])
+                if len(arguments) == 1 and isinstance(arguments[0], dict):
+                    expression = node["expression"]
+                    expr_node_id = expression["id"]
+                    arg_type_str = expression["argumentTypes"][0]["typeString"]
+                    if not is_int_type(arg_type_str):
+                        continue
+                    if "typeName" not in expression:
+                        continue
+                    expr_type_node = expression["typeName"]
+                    if isinstance(expr_type_node, str):
+                        expr_type_str = expr_type_node
+                    else:
+                        expr_type_str = expr_type_node["name"]
+                    if not is_int_type(expr_type_str):
+                        continue
+                    conversions.append(CastInfo(arg_type_str, expr_type_str, expr_node_id))
+
+    return conversions
+
+
+def casting_func_name(counter: int) -> str:
+    return f"cast_{counter}"
+
+
+def generate_casting_function(assembly_prefix: str, cast_info: CastInfo, counter: int) -> str:
+    """
+    returns the text of a solidity function that does casting according to CastInfo. It also has an encoded mload
+    call, to be decoded later on the kotlin side if we run the `safeCasting` builtin rule.
+    """
+    conversion_string = assembly_prefix + \
+        "{ mstore(0xffffff6e4604afefe123321beef1b03fffffffffffffffffffff" + \
+        f'{"%0.4x" % counter}{"%0.4x" % encode_type(cast_info.arg_type_str)}{"%0.4x" % encode_type(cast_info.res_type_str)}, x)' + "}"
+    function_head = f"function {casting_func_name(counter)}({cast_info.arg_type_str} x) internal pure returns ({cast_info.res_type_str})"
+    return function_head + "{\n" + conversion_string + f"return {cast_info.res_type_str}(x);\n" "}\n"
+
+
+def generate_casting_instrumentation(asts: Dict[str, Dict[str, Dict[int, Any]]], contract_file: str, sdc: SDC) \
+        -> tuple[Dict[str, Dict[int, Instrumentation]], Dict[str, tuple[str, list[str]]]]:
+    """
+    Generate instrumentation for integer type casts in Solidity code.
+
+    Returns a tuple of:
+    - casting_instrumentation: Maps file paths to offset->Instrumentation mappings that replace type names with
+      library calls to casting functions we generate.
+    - casting_types: Maps file paths to library_name and the text for our new casting functions. This library is added
+      to the end of the file.
+
+    It's not hundred precent sure this works well in combination with `compiler_map`, because the counter for library
+    names may reset?
+    """
+    casting_instrumentation: Dict[str, Dict[int, Instrumentation]] = dict()
+
+    if not isinstance(sdc.compiler_collector, CompilerCollectorSol):
+        raise Exception(f"Encountered a compiler collector that is not solc for file {contract_file}"
+                        " when trying to add casting instrumentation")
+    assembly_prefix = sdc.compiler_collector.gen_memory_safe_assembly_prefix()
+
+    casting_funcs : Dict[str, tuple[str, list[str]]] = dict()
+    counter = 0
+    original_files = sorted({Util.convert_path_for_solc_import(c.original_file) for c in sdc.contracts})
+    for file_count, solfile in enumerate(original_files, start=1):
+        main_ast = asts[contract_file]
+        curr_file_ast = main_ast.get(solfile, dict())
+
+        per_file_inst = casting_instrumentation.setdefault(solfile, dict())
+        libname, per_file_casts = casting_funcs.setdefault(solfile, (f"CertoraCastingLib{file_count}", []))
+
+        casts = find_casts(curr_file_ast)
+        for cast_info in casts:
+            start_offset, src_len, file = curr_file_ast[cast_info.expr_id]["src"].split(":")
+            counter += 1
+            per_file_inst[int(start_offset)] = Instrumentation(expected=bytes(cast_info.res_type_str[0], 'utf-8'),
+                                                               to_ins=f"{libname}.{casting_func_name(counter)}",
+                                                               mut=Replace(len(cast_info.res_type_str)))
+            new_func = generate_casting_function(assembly_prefix, cast_info, counter)
+            per_file_casts.append(new_func)
+
+    return casting_instrumentation, casting_funcs
+
+
+def iter_all_nodes(node: Any) -> Generator[Any, Optional[Any], None]:
+    """
+    Yield a node and all its subnodes in depth-first order.
+    Works with dict nodes that may contain nested dicts and lists.
+    """
+    yield node
+
+    if isinstance(node, dict):
+        for value in node.values():
+            if isinstance(value, (dict, list)):
+                yield from iter_all_nodes(value)
+    elif isinstance(node, list):
+        for item in node:
+            if isinstance(item, (dict, list)):
+                yield from iter_all_nodes(item)

certora_cli/CertoraProver/certoraApp.py

@@ -0,0 +1,52 @@
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import CertoraProver.certoraContextAttributes as Attrs
+from Shared import certoraAttrUtil as AttrUtil
+
+
+from abc import ABC
+from typing import Type
+
+
+class CertoraApp(ABC):
+    attr_class: Type[AttrUtil.Attributes] = Attrs.EvmProverAttributes
+
+class EvmAppClass(CertoraApp):
+    pass
+
+class EvmApp(EvmAppClass):
+    pass
+
+class RustAppClass(CertoraApp):
+    pass
+
+class MoveAppClass(CertoraApp):
+    pass
+
+class SolanaApp(RustAppClass):
+    attr_class = Attrs.SolanaProverAttributes
+
+class SorobanApp(RustAppClass):
+    attr_class = Attrs.SorobanProverAttributes
+
+class RangerApp(EvmAppClass):
+    attr_class = Attrs.RangerAttributes
+
+class ConcordApp(EvmAppClass):
+    attr_class = Attrs.ConcordAttributes
+
+class SuiApp(MoveAppClass):
+    attr_class = Attrs.SuiProverAttributes