certora-cli 7.0.7__tar.gz → 7.3.0__tar.gz

{certora-cli-7.0.7/certora_cli.egg-info → certora-cli-7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certora-cli
-Version: 7.0.7
+Version: 7.3.0
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli
 Author: Certora
@@ -21,4 +21,4 @@ Requires-Dist: tabulate
 Requires-Dist: tqdm
 Requires-Dist: StrEnum
 
-Commit e6a2b44.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 3dce873.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora-cli-7.3.0/README.md

@@ -0,0 +1 @@
+Commit 3dce873.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

{certora-cli-7.0.7 → certora-cli-7.3.0}/certora_cli/EVMVerifier/Compiler/CompilerCollector.py

@@ -131,6 +131,30 @@ class CompilerLang(metaclass=AbstractAndSingleton):
         """
         pass
 
+    @property
+    @abstractmethod
+    def supports_typed_immutables(self) -> bool:
+        """
+        :return: True if has type information associated to immutables
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def supports_ast_output(self) -> bool:
+        """
+        :return: True if compiling contracts in this language produces AST output
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def supports_srclist_output(self) -> bool:
+        """
+        :return: True if compiling contracts in this language produces srclist output
+        """
+        pass
+
 
 class CompilerCollector(ABC):
     """

{certora-cli-7.0.7 → certora-cli-7.3.0}/certora_cli/EVMVerifier/Compiler/CompilerCollectorFactory.py

@@ -9,6 +9,7 @@ import re
 import logging
 from EVMVerifier.Compiler.CompilerCollector import CompilerLang, CompilerCollector
 from EVMVerifier.Compiler.CompilerCollectorSol import CompilerCollectorSol, CompilerLangSol
+from EVMVerifier.Compiler.CompilerCollectorYul import CompilerLangYul, CompilerCollectorYul
 from EVMVerifier.Compiler.CompilerCollectorVy import CompilerCollectorVy, CompilerLangVy
 from Shared.certoraUtils import is_windows, match_path_to_mapping_key, remove_file, get_certora_config_dir
 from EVMVerifier.certoraContextClass import CertoraContext
@@ -71,9 +72,12 @@ class CompilerCollectorFactory:
             return CompilerCollectorVy(version)
         elif str(path).endswith(".sol"):
             version = self.__get_solc_version(path)
-            return CompilerCollectorSol(version)
+            return CompilerCollectorSol(version, CompilerLangSol(), self.context.use_memory_safe_autofinders)
+        elif str(path).endswith(".yul"):
+            version = self.__get_solc_version(path)
+            return CompilerCollectorYul(version, CompilerLangYul())
         else:
-            raise RuntimeError(f'expected {path} to represent a Solidity or Vyper file')
+            raise RuntimeError(f'expected {path} to represent a Solidity, Yul, or Vyper file')
 
     @staticmethod
     def get_vyper_compiler(contract_file_path: Path, default_compiler: str, compiler_mappings: Dict[str, str]) -> str:
@@ -170,5 +174,7 @@ def get_compiler_lang(file_name: str) -> CompilerLang:
         return CompilerLangVy()
     elif file_name.endswith(".sol"):
         return CompilerLangSol()
+    elif file_name.endswith(".yul"):
+        return CompilerLangYul()
     else:
         raise RuntimeError(f'expected {file_name} to represent a Solidity or Vyper file')

{certora-cli-7.0.7 → certora-cli-7.3.0}/certora_cli/EVMVerifier/Compiler/CompilerCollectorSol.py

@@ -1,7 +1,8 @@
 from pathlib import Path
 from typing import Any, List, Tuple, Dict, Set
 
-from EVMVerifier.Compiler.CompilerCollector import CompilerLang, CompilerCollector, CompilerLangFunc
+from EVMVerifier.Compiler.CompilerCollector import CompilerLang, CompilerLangFunc
+from EVMVerifier.Compiler.CompilerCollectorSolBased import CompilerCollectorSolBased
 from Shared.certoraUtils import Singleton, CompilerVersion, get_certora_config_dir
 import EVMVerifier.certoraType as CT
 
@@ -62,33 +63,44 @@ class CompilerLangSol(CompilerLang, metaclass=Singleton):
             Tuple[List[CT.Type], List[CompilerLangFunc]]:
         assert False, "collect_source_type_descriptions() has not yet been implemented in CompilerLangSol"
 
-
-# This class is intended for calculations of compiler-settings related queries
-class CompilerCollectorSol(CompilerCollector):
-
-    def __init__(self, version: CompilerVersion):
-        self.__compiler_version = version
-
     @property
-    def compiler_name(self) -> str:
-        return self.smart_contract_lang.compiler_name
+    def supports_typed_immutables(self) -> bool:
+        return True
 
     @property
-    def smart_contract_lang(self) -> CompilerLangSol:
-        return CompilerLangSol()
+    def supports_ast_output(self) -> bool:
+        return True
 
     @property
-    def compiler_version(self) -> CompilerVersion:
-        return self.__compiler_version
+    def supports_srclist_output(self) -> bool:
+        return True
+
+
+# This class is intended for calculations of compiler-settings related queries
+class CompilerCollectorSol(CompilerCollectorSolBased):
+
+    def __init__(self, version: CompilerVersion, lang: CompilerLang, use_memory_safe_autofinders: bool):
+        super().__init__(version, lang)
+        self.__use_memory_safe_autofinders = use_memory_safe_autofinders
 
     def normalize_storage(self, is_storage: bool, arg_name: str) -> str:
         if not is_storage:
             return arg_name
-        if self.__compiler_version[0] == 0 and self.__compiler_version[1] < 7:
+        if self.compiler_version[0] == 0 and self.compiler_version[1] < 7:
             return arg_name + "_slot"
         else:
             return arg_name + ".slot"
 
     def supports_calldata_assembly(self, arg_name: str) -> bool:
-        return (self.__compiler_version[1] > 7 or (
-                self.__compiler_version[1] == 7 and self.__compiler_version[2] >= 5)) and arg_name != ""
+        return (self.compiler_version[1] > 7 or (
+                self.compiler_version[1] == 7 and self.compiler_version[2] >= 5)) and arg_name != ""
+
+    def supports_memory_safe_assembly(self) -> bool:
+        return (self.compiler_version[1] > 8 or (
+                self.compiler_version[1] == 8 and self.compiler_version[2] >= 13))
+
+    def gen_memory_safe_assembly_prefix(self) -> str:
+        if self.supports_memory_safe_assembly() and self.__use_memory_safe_autofinders:
+            return 'assembly ("memory-safe")'
+        else:
+            return 'assembly'

certora-cli-7.3.0/certora_cli/EVMVerifier/Compiler/CompilerCollectorSolBased.py

@@ -0,0 +1,21 @@
+from EVMVerifier.Compiler.CompilerCollector import CompilerCollector, CompilerLang
+from Shared.certoraUtils import CompilerVersion
+
+
+class CompilerCollectorSolBased(CompilerCollector):
+
+    def __init__(self, version: CompilerVersion, lang: CompilerLang):
+        self.__compiler_version = version
+        self.__smart_contract_lang = lang
+
+    @property
+    def compiler_name(self) -> str:
+        return self.smart_contract_lang.compiler_name
+
+    @property
+    def smart_contract_lang(self) -> CompilerLang:
+        return self.__smart_contract_lang
+
+    @property
+    def compiler_version(self) -> CompilerVersion:
+        return self.__compiler_version

{certora-cli-7.0.7 → certora-cli-7.3.0}/certora_cli/EVMVerifier/Compiler/CompilerCollectorVy.py

@@ -491,6 +491,18 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
     vyper_constructor_name = "__init__"
 
+    @property
+    def supports_typed_immutables(self) -> bool:
+        return True
+
+    @property
+    def supports_ast_output(self) -> bool:
+        return True
+
+    @property
+    def supports_srclist_output(self) -> bool:
+        return True
+
     @staticmethod
     def extract_constant(ast_node: Dict[str, Any], named_constants: Dict[str, int]) -> int:
         """

certora-cli-7.3.0/certora_cli/EVMVerifier/Compiler/CompilerCollectorYul.py

@@ -0,0 +1,90 @@
+import json
+from typing import List
+
+from Crypto.Hash import keccak
+
+from EVMVerifier.Compiler.CompilerCollector import CompilerLang
+from EVMVerifier.Compiler.CompilerCollectorSol import CompilerLangSol
+from EVMVerifier.Compiler.CompilerCollectorSolBased import CompilerCollectorSolBased
+from EVMVerifier.certoraContractFuncs import Func
+from Shared.certoraUtils import Singleton, CompilerVersion
+import EVMVerifier.certoraType as CT
+
+
+class CompilerLangYul(CompilerLangSol, metaclass=Singleton):
+    """
+    [CompilerLang] for Yul
+    """
+
+    @property
+    def name(self) -> str:
+        return "Yul"
+
+    @property
+    def supports_typed_immutables(self) -> bool:
+        return False
+
+    @property
+    def supports_ast_output(self) -> bool:
+        return False
+
+    @property
+    def supports_srclist_output(self) -> bool:
+        return False
+
+    @staticmethod
+    def get_sighash(name: str, full_args: List[CT.TypeInstance]) -> str:
+        sig = Func.compute_signature(name, full_args, lambda x: x.get_source_str())
+        f_hash = keccak.new(digest_bits=256)
+        f_hash.update(str.encode(sig))
+
+        return f_hash.hexdigest()[0:8]
+
+    def get_funcs(self, yul_abi_json_filepath: str, contract_name: str) -> List[Func]:
+        funcs = []
+        with open(yul_abi_json_filepath, 'r') as yul_abi_json_file:
+            yul_abi_json = json.load(yul_abi_json_file)
+            for entry in yul_abi_json:
+                if "type" in entry and entry["type"] == "function":
+                    name = entry["name"]
+                    state_mutability = entry["stateMutability"]
+                    full_args = []
+                    param_names = []
+                    for input in entry["inputs"]:
+                        type_name = input["type"]
+                        # yul abi is annoying. no better way
+                        if type_name.endswith("[]"):
+                            base = type_name[:-2]
+                            base_type = CT.Type.from_primitive_name(base)
+                            out_type: CT.Type = CT.ArrayType(type_name, base_type, None, contract_name, 0)
+                        elif type_name == "bytes":
+                            out_type = CT.PackedBytes()
+                        else:
+                            out_type = CT.Type.from_primitive_name(input["type"])
+                        full_args.append(CT.TypeInstance(out_type))
+                        param_names.append(input["name"])
+                    returns = []
+                    for output in entry["outputs"]:
+                        type_name = output["type"]
+                        # yul abi is annoying. no better way
+                        if type_name.endswith("[]"):
+                            base = type_name[:-2]
+                            base_type = CT.Type.from_primitive_name(base)
+                            out_type = CT.ArrayType(type_name, base_type, None, contract_name, 0)
+                        elif type_name == "bytes":
+                            out_type = CT.PackedBytes()
+                        else:
+                            out_type = CT.Type.from_primitive_name(output["type"])
+                        returns.append(CT.TypeInstance(out_type))
+                    visibility = "external"
+                    sighash = self.get_sighash(name, full_args)
+                    notpayable = state_mutability in ["nonpayable", "view", "pure"]
+
+                    funcs.append(Func(name, full_args, param_names, returns, sighash, notpayable, False, False,
+                                      state_mutability, visibility, True, False, contract_name, None, None))
+        return funcs
+
+
+class CompilerCollectorYul(CompilerCollectorSolBased):
+    def __init__(self, version: CompilerVersion, lang: CompilerLang):
+        super().__init__(version, lang)