certora-cli-beta-mirror 8.4.3__tar.gz → 8.5.0__tar.gz

{certora_cli_beta_mirror-8.4.3/certora_cli_beta_mirror.egg-info → certora_cli_beta_mirror-8.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli-beta-mirror
-Version: 8.4.3
+Version: 8.5.0
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli-beta-mirror
 Author: Certora
@@ -39,4 +39,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 0d90215.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit d143e0e.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli_beta_mirror-8.5.0/README.md

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

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/Compiler/CompilerCollectorVy.py

@@ -659,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
@@ -1273,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)
@@ -1300,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_beta_mirror-8.5.0/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_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/certoraBuild.py

@@ -20,24 +20,24 @@ import os
 import re
 import shutil
 import sys
+import tempfile
 import typing
 from collections import OrderedDict, defaultdict
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
-from Crypto.Hash import keccak
-import tempfile
-
 from typing import Any, Dict, List, Tuple, Optional, Set, Iterator, NoReturn
 
+from Crypto.Hash import keccak
 
+from CertoraProver.castingInstrumenter import generate_casting_instrumentation
 from CertoraProver.certoraBuildCacheManager import CertoraBuildCacheManager, CachedFiles
 from CertoraProver.certoraBuildDataClasses import CONTRACTS, ImmutableReference, ContractExtension, ContractInSDC, SDC, \
     Instrumentation, InsertBefore, InsertAfter, UnspecializedSourceFinder, instrumentation_logger
 from CertoraProver.certoraCompilerParameters import SolcParameters
+from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes, VyperMetadata
 from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
-from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
 sys.path.insert(0, str(scripts_dir_path))
@@ -1381,11 +1381,17 @@ class CertoraBuildGenerator:
 
         return bytecode
 
-    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
-        match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_via_ir')
-        assert isinstance(match, (bool, type(None))), f"Expected solc_via_ir to be bool or None, got {type(match)}"
+    def get_map_bool_attribute_value(self, contract_file_path: Path, attr_name: str) -> bool:
+        match = Ctx.get_map_attribute_value(self.context, contract_file_path, attr_name)
+        assert isinstance(match, (bool, type(None))), f"Expected {attr_name} to be bool or None, got {type(match)}"
         return bool(match)
 
+    def get_solc_via_ir_value(self, contract_file_path: Path) -> bool:
+        return self.get_map_bool_attribute_value(contract_file_path, 'solc_via_ir')
+
+    def get_vyper_venom_value(self, contract_file_path: Path) -> bool:
+        return self.get_map_bool_attribute_value(contract_file_path, 'vyper_venom')
+
     def get_solc_evm_version_value(self, contract_file_path: Path) -> Optional[str]:
         match = Ctx.get_map_attribute_value(self.context, contract_file_path, 'solc_evm_version')
         assert isinstance(match, (str, type(None))), f"Expected solc_evm_version to be string or None, got {type(match)}"
@@ -1398,6 +1404,10 @@ class CertoraBuildGenerator:
             match = str(match)
         return match
 
+    def _handle_venom(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
+        if self.get_vyper_venom_value(contract_file_path):
+            settings_dict["experimentalCodegen"] = True
+
     def _handle_via_ir(self, contract_file_path: Path, settings_dict: Dict[str, Any]) -> None:
         if self.get_solc_via_ir_value(contract_file_path):
             settings_dict["viaIR"] = True
@@ -1510,6 +1520,9 @@ class CertoraBuildGenerator:
         self._handle_via_ir(contract_file_path, settings_dict)
         self._handle_evm_version(contract_file_path, settings_dict)
         self._handle_optimize(contract_file_path, settings_dict, compiler_collector)
+        compiler_lang = compiler_collector.smart_contract_lang
+        if compiler_lang == CompilerLangVy():
+            self._handle_venom(contract_file_path, settings_dict)
 
     @staticmethod
     def solc_setting_optimizer_runs(settings_dict: Dict[str, Any]) -> Tuple[bool, Optional[int]]:
@@ -1569,6 +1582,8 @@ class CertoraBuildGenerator:
                 contents = f.read()
                 sources_dict = {str(contract_file_posix_abs): {"content": contents}}
                 output_selection = ["abi", "evm.bytecode", "evm.deployedBytecode", "evm.methodIdentifiers"]
+                if compiler_collector.compiler_version >= (0, 4, 4):
+                    output_selection += ["metadata", "evm.deployedBytecode.symbolMap"]
                 ast_selection = ["ast"]
 
         settings_dict: Dict[str, Any] = \
@@ -2225,6 +2240,40 @@ class CertoraBuildGenerator:
             storage_slot['descriptor'] = type_descriptor.as_dict()
         return storage_data
 
+    @staticmethod
+    def add_vyper_internal_function_data(internal_funcs: Set[Func], contract_data: Dict[str, Any]) -> None:
+        metadata = contract_data["metadata"]
+        symbol_map = contract_data["evm"]["deployedBytecode"]["symbolMap"]
+
+        for internal_func in internal_funcs:
+            # find metadata entry
+            func_name = internal_func.name
+            func_info = metadata['function_info']
+            metadata_func_info = None
+            for value in func_info.values():
+                if value.get("name") == func_name:
+                    metadata_func_info = value
+                    break
+            assert metadata_func_info is not None, f"Could not find metadata for internal function {func_name}"
+            vyper_metadata = VyperMetadata()
+            if metadata_func_info.get('frame_info'):
+                vyper_metadata.frame_size = metadata_func_info['frame_info']['frame_size']
+                vyper_metadata.frame_start = metadata_func_info['frame_info']['frame_start']
+            if metadata_func_info.get('venom_via_stack'):
+                vyper_metadata.venom_via_stack = metadata_func_info['venom_via_stack']
+            if metadata_func_info.get('venom_return_via_stack'):
+                vyper_metadata.venom_return_via_stack = metadata_func_info['venom_return_via_stack']
+            pattern_in_symbol_map = re.compile(fr"{func_name}\(.*\)_runtime$")
+            matches = [k for k in symbol_map if pattern_in_symbol_map.search(k)]
+            if len(matches) == 0:
+                build_logger.warning(f"Could not find symbol map entry for {func_name} probably was inlined")
+                continue
+            elif len(matches) > 1:
+                raise RuntimeError(f"Found multiple matches for {func_name} in symbol map: {matches}")
+            else:
+                vyper_metadata.runtime_start_pc = symbol_map[matches[0]]
+            internal_func.vyper_metadata = vyper_metadata
+
     def get_contract_in_sdc(self,
                             source_code_file: str,
                             contract_name: str,
@@ -2349,6 +2398,9 @@ class CertoraBuildGenerator:
         else:
             compiler_parameters = None
 
+        if compiler_lang == CompilerLangVy() and compiler_collector_for_contract_file.compiler_version >= (0, 4, 4):
+            self.add_vyper_internal_function_data(internal_funcs, contract_data)
+
         return ContractInSDC(contract_name,
                              # somehow make sure this is an absolute path which obeys the autofinder remappings
                              # (i.e. make sure this file doesn't start with autoFinder_)
@@ -2865,6 +2917,8 @@ class CertoraBuildGenerator:
 
                 self.SDCs[self.get_sdc_key(sdc.primary_contract, sdc.primary_contract_address)] = sdc
 
+        if self.context.dump_asts:
+            self.dump_asts()
         self.handle_links()
         self.handle_struct_links()
         self.handle_contract_extensions()
@@ -3285,6 +3339,15 @@ class CertoraBuildGenerator:
         else:
             added_source_finders = {}
 
+        try:
+            casting_instrumentations, casting_types = generate_casting_instrumentation(self.asts, build_arg_contract_file, sdc_pre_finder)
+        except Exception as e:
+            instrumentation_logger.warning(
+                f"Computing casting instrumentation failed for {build_arg_contract_file}: {e}", exc_info=True)
+            casting_instrumentations, casting_types = {}, {}
+
+        instr = CertoraBuildGenerator.merge_dicts_instrumentation(instr, casting_instrumentations)
+
         abs_build_arg_contract_file = Util.abs_posix_path(build_arg_contract_file)
         if abs_build_arg_contract_file not in instr:
             instrumentation_logger.debug(
@@ -3338,6 +3401,13 @@ class CertoraBuildGenerator:
                         read_so_far += amt + 1 + to_skip
                     output.write(in_file.read(-1))
 
+                    library_name, funcs = casting_types.get(contract_file, ("", list()))
+                    if len(funcs) > 0:
+                        output.write(bytes(f"\nlibrary {library_name}" + "{\n", "utf8"))
+                        for f in funcs:
+                            output.write(bytes(f, "utf8"))
+                        output.write(bytes("}\n", "utf8"))
+
         new_file = self.to_autofinder_file(build_arg_contract_file)
         self.context.file_to_contract[new_file] = self.context.file_to_contract[
             build_arg_contract_file]
@@ -3813,6 +3883,16 @@ class CertoraBuildGenerator:
             # Avoiding Python interpreter shutdown exceptions which are safe to ignore
             pass
 
+    def dump_asts(self) -> None:
+        asts_dump_file = Util.get_asts_file()
+        filtered_asts = {k: v for k, v in self.asts.items() if not str(k).startswith(f"{Util.get_build_dir()}")}
+        with asts_dump_file.open("w+") as output_file:
+            try:
+                json.dump(filtered_asts, output_file, indent=4, sort_keys=True)
+            except Exception as e:
+                ast_logger.debug(f"Couldn't dump ASTs to {asts_dump_file}", exc_info=e)
+                raise
+
 
 # make sure each source file exists and its path is in absolute format
 def sources_to_abs(sources: Set[Path]) -> Set[Path]:

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/certoraBuildDataClasses.py

@@ -189,6 +189,7 @@ class ContractInSDC:
             # why are we using this and not the normal list of functions?
             "internalFunctions": {key: method.as_dict() for key, method in self.function_finders.items()},
             # this doesn't even have all functions
+            "internalFuncs": [f.as_dict() for f in self.internal_funcs],
             "allMethods": [f.as_dict() for f in self.all_funcs],
             "solidityTypes": [x.as_dict() for x in self.types],
             "compilerName": "" if not self.compiler_collector else self.compiler_collector.compiler_name,

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/certoraCompilerParameters.py

@@ -35,3 +35,14 @@ class SolcParameters(CompilerParameters):
         as_dict.update({"optimizerOn": self.optimizer_on, "optimizerRuns": self.optimizer_runs, "viaIR": self.via_ir,
                         "type": "SolcParameters"})
         return as_dict
+
+class VyperParameters(CompilerParameters):
+
+    def __init__(self, is_venom: bool):
+        self.is_venom = is_venom
+        CompilerParameters.__init__(self)
+
+    def as_dict(self) -> Dict[str, Any]:
+        as_dict = CompilerParameters.as_dict(self)
+        as_dict.update({"is_venom": self.is_venom, "type": "VyperParameters"})
+        return as_dict

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/certoraContextAttributes.py

@@ -298,6 +298,34 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False
     )
 
+    VYPER_VENOM_MAP = AttrUtil.AttributeDefinition(
+        attr_validation_func=Vf.validate_vyper_venom_map,
+        arg_type=AttrUtil.AttrArgType.MAP,
+        help_msg="Map contracts to the appropriate experimental-codegen option (Vyper >= 4 only)",
+        default_desc="All contracts are compiled without experimental codegen",
+        argparse_args={
+            "action": AttrUtil.UniqueStore,
+            "type": lambda value: Vf.parse_ordered_dict("vyper_venom_map", value, bool)
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False,
+        config_data=AttributeJobConfigData(main_section=MainSection.SOLIDITY_COMPILER)
+    )
+
+    VYPER_VENOM = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        help_msg="Whether to use experimental-codegen (Vyper >= 4 only)",
+        default_desc="All contracts are compiled without experimental codegen",
+        argparse_args={
+            "action": AttrUtil.STORE_TRUE
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False,
+        config_data=AttributeJobConfigData(
+            main_section=MainSection.SOLIDITY_COMPILER
+        )
+    )
+
     SOLC_VIA_IR = AttrUtil.AttributeDefinition(
         arg_type=AttrUtil.AttrArgType.BOOLEAN,
         help_msg="Pass the `--via-ir` flag to the Solidity compiler",
@@ -1163,6 +1191,17 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False,
     )
 
+    DUMP_ASTS = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        help_msg="dump all solidity files' asts to asts.json in the build directory",
+        default_desc="asts are not saved",
+        argparse_args={
+            'action': AttrUtil.STORE_TRUE
+        },
+        affects_build_cache_key=False,
+        disables_build_cache=False,
+    )
+
     @classmethod
     def hide_attributes(cls) -> List[str]:
         # do not show these attributes in the help message

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/certoraContextValidator.py

@@ -417,8 +417,6 @@ def check_vyper_flag(context: CertoraContext) -> None:
         vy_paths = [path for path in context.files if path.endswith(".vy")]
         if not vy_paths:
             validation_logger.warning("vyper attribute was set but no Vyper files were set")
-        if context.solc:
-            raise Util.CertoraUserInputError("cannot set both vyper attribute and solc attribute")
 
 def check_contract_name_arg_inputs(context: CertoraContext) -> None:
     """

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/CertoraProver/certoraContractFuncs.py

@@ -13,7 +13,7 @@
 #     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 typing import List, Optional, Tuple, Dict, Any
+from typing import List, Optional, Tuple, Dict, Any, cast
 from CertoraProver import certoraType as CT
 from Shared import certoraUtils as Util
 
@@ -46,6 +46,30 @@ class SourceBytes:
         except (KeyError, ValueError):
             return None
 
+class VyperMetadata:
+    def __init__(
+        self,
+        frame_size: Optional[int] = None,
+        frame_start: Optional[int] = None,
+        venom_via_stack: Optional[List[str]] = None,
+        venom_return_via_stack: bool = False,
+        runtime_start_pc: Optional[int] = None,
+    ):
+        self.frame_size = frame_size
+        self.frame_start = frame_start
+        self.venom_via_stack = venom_via_stack
+        self.venom_return_via_stack = venom_return_via_stack
+        self.runtime_start_pc = runtime_start_pc
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "frame_size": self.frame_size,
+            "frame_start": self.frame_start,
+            "venom_via_stack": self.venom_via_stack,
+            "venom_return_via_stack": self.venom_return_via_stack,
+            "runtime_start_pc": self.runtime_start_pc,
+        }
+
 
 class Func:
     def __init__(self,
@@ -69,6 +93,7 @@ class Func:
                  original_file: Optional[str],
                  location: Optional[str],
                  body_location: Optional[str],
+                 vyper_metadata: Optional[VyperMetadata] = None
                  ):
         self.name = name
         self.fullArgs = fullArgs
@@ -90,6 +115,7 @@ class Func:
         self.virtual = virtual
         self.contractName = contractName
         self.source_bytes = source_bytes
+        self.vyper_metadata = vyper_metadata
 
     def as_dict(self) -> Dict[str, Any]:
         return {
@@ -105,6 +131,7 @@ class Func:
             "contractName": self.contractName,
             "sourceBytes": None if self.source_bytes is None else self.source_bytes.as_dict(),
             "originalFile": None if self.original_file is None else Util.resolve_original_file(self.original_file),
+            "vyper_metadata": cast(VyperMetadata, self.vyper_metadata).as_dict() if self.vyper_metadata is not None else None
         }
 
     def name_for_contract(self, contract_name: str) -> str:

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/Shared/certoraUtils.py

@@ -265,6 +265,8 @@ def get_debug_log_file() -> Path:
 def get_extension_info_file() -> Path:
     return path_in_build_directory(Path(".vscode_extension_info.json"))
 
+def get_asts_file() -> Path:
+    return path_in_build_directory(Path(".asts.json"))
 
 def get_zip_output_url_file() -> Path:
     return CERTORA_INTERNAL_ROOT / '.zip-output-url.txt'

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli/Shared/certoraValidateFuncs.py

@@ -667,14 +667,14 @@ def validate_address(value: str) -> str:
     return value
 
 
-def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
+def validate_boolean_map(args: Dict[str, bool], attr_name: str) -> None:
+    attr_map_name = attr_name + "_map"
     if not isinstance(args, dict):
-        raise Util.CertoraUserInputError("'solc_via_ir_map' should be stored as a map "
-                                         f"(type was {type(args).__name__})")
+        raise Util.CertoraUserInputError(f"'{attr_map_name}' should be stored as a map (type was {type(args).__name__})")
 
     for contract, value in args.items():
         if not isinstance(value, bool):
-            raise Util.CertoraUserInputError(f"'solc_via_ir_map' should map {contract} to a boolean value, "
+            raise Util.CertoraUserInputError(f"'{attr_map_name}' should map {contract} to a boolean value, "
                                              f"got ({value}, type: {type(value).__name__})")
 
     values = args.values()
@@ -682,9 +682,15 @@ def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
 
     if all(x == first for x in values):
         if first:
-            validation_logger.warning("all via_ir values are set to True '--solc_via_ir' can be used instead")
+            validation_logger.warning(f"all {attr_map_name} values are set to True '{attr_name}' can be used instead")
         else:
-            validation_logger.warning("all via_ir values are set to False, this flag/attribute can be omitted")
+            validation_logger.warning(f"all {attr_map_name} values are set to False, this flag/attribute can be omitted")
+
+def validate_solc_via_ir_map(args: Dict[str, bool]) -> None:
+    validate_boolean_map(args, 'solc_via_ir')
+
+def validate_vyper_venom_map(args: Dict[str, bool]) -> None:
+    validate_boolean_map(args, 'vyper_venom')
 
 def validate_solc_evm_version_map(args: Dict[str, str]) -> None:
     if not isinstance(args, dict):
@@ -838,7 +844,7 @@ def validate_evm_rule_name(rule_str: str) -> str:
         return __validate_solidity_id(rule_str, "rule")
 
 def validate_move_function_name(name: str) -> str:
-    if not re.match(r"^0x[0-9a-fA-F]+::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$", name):
+    if not re.match(r"^(0x[0-9a-fA-F]+|([a-zA-Z_][a-zA-Z0-9_]*))::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$", name):
         raise Util.CertoraUserInputError(f"invalid Move function name \"{name}\": must be a fully-qualified Move "
                                          "function name")
     return name
@@ -859,7 +865,7 @@ def validate_msg(msg: str) -> str:
         msg = (msg[:MAX_MSG_LEN - 3] + "...")
         validation_logger.warning(f"'msg' can't accept strings longer than {MAX_MSG_LEN} chars, string was truncated")
 
-    additional_chars = {'(', ' ', ',', '/', '[', "'", '-', '"', '_', ']', '.', ')', ':', '\\', '='}
+    additional_chars = {'(', ' ', ',', '/', '[', "'", '-', '"', '_', ']', '.', ')', ':', '\\', '=', '*', '$'}
     valid_chars = set(string.ascii_letters) | set(string.digits) | additional_chars
     invalid_chars = set(msg) - valid_chars
     if len(invalid_chars) > 0:

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0/certora_cli_beta_mirror.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli-beta-mirror
-Version: 8.4.3
+Version: 8.5.0
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli-beta-mirror
 Author: Certora
@@ -39,4 +39,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 0d90215.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit d143e0e.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/certora_cli_beta_mirror.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ certora_cli/certoraSorobanProver.py
 certora_cli/certoraSuiProver.py
 certora_cli/rustMutator.py
 certora_cli/CertoraProver/__init__.py
+certora_cli/CertoraProver/castingInstrumenter.py
 certora_cli/CertoraProver/certoraApp.py
 certora_cli/CertoraProver/certoraBuild.py
 certora_cli/CertoraProver/certoraBuildCacheManager.py

certora_cli_beta_mirror-8.5.0/certora_jars/CERTORA-CLI-VERSION-METADATA.json

@@ -0,0 +1 @@
+{"name": "certora-cli-beta-mirror", "tag": "8.5.0", "branch": "", "commit": "d143e0e", "timestamp": "20251116.12.6.675546", "version": "8.5.0"}

{certora_cli_beta_mirror-8.4.3 → certora_cli_beta_mirror-8.5.0}/setup.py

@@ -3,11 +3,11 @@ import setuptools
 
 setuptools.setup(
     name="certora-cli-beta-mirror",
-    version="8.4.3",
+    version="8.5.0",
     author="Certora",
     author_email="support@certora.com",
     description="Runner for the Certora Prover",
-    long_description="Commit 0d90215.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.",
+    long_description="Commit d143e0e.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.",
     long_description_content_type="text/markdown",
     url="https://pypi.org/project/certora-cli-beta-mirror",
     packages=setuptools.find_packages(),

certora_cli_beta_mirror-8.4.3/README.md

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

certora_cli_beta_mirror-8.4.3/certora_jars/CERTORA-CLI-VERSION-METADATA.json

@@ -1 +0,0 @@
-{"name": "certora-cli-beta-mirror", "tag": "8.4.3", "branch": "", "commit": "0d90215", "timestamp": "20251030.12.0.379579", "version": "8.4.3"}