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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certora-cli
-Version: 6.3.1
+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 1c08d79.                    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-6.3.1 → certora-cli-7.3.0}/certora_cli/EVMVerifier/Compiler/CompilerCollector.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod, ABC
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Set
 from Shared.certoraUtils import AbstractAndSingleton, CompilerVersion
@@ -6,39 +7,23 @@ import EVMVerifier.certoraType as CT
 
 
 # TODO: merge this with Func in certoraBuild
+@dataclass
 class CompilerLangFunc:
-    def __init__(self,
-                 name: str,
-                 fullargs: List[CT.TypeInstance],
-                 paramnames: List[str],
-                 returns: List[CT.TypeInstance],
-                 sighash: str,
-                 notpayable: bool,
-                 fromlib: bool,  # not serialized
-                 isconstructor: bool,  # not serialized
-                 statemutability: str,
-                 visibility: str,
-                 implemented: bool,  # does this function have a body? (false for interface functions)
-                 overrides: bool,  # does this function override an interface declaration or super-contract definition?
-                 contractName: str,
-                 ast_id: Optional[int] = None,
-                 where: Optional[Tuple[str, str]] = None  # 1st element: source file name, 2nd element: location string
-                 ):
-        self.name = name
-        self.fullArgs = fullargs
-        self.paramNames = paramnames
-        self.returns = returns
-        self.sighash = sighash
-        self.notpayable = notpayable
-        self.fromLib = fromlib
-        self.isConstructor = isconstructor
-        self.stateMutability = statemutability
-        self.visibility = visibility
-        self.where = where
-        self.implemented = implemented
-        self.ast_id = ast_id
-        self.overrides = overrides
-        self.contractName = contractName
+    name: str
+    fullArgs: List[CT.TypeInstance]
+    paramNames: List[str]
+    returns: List[CT.TypeInstance]
+    sighash: str
+    notpayable: bool
+    fromLib: bool  # not serialized
+    isConstructor: bool  # not serialized
+    stateMutability: str
+    visibility: str
+    implemented: bool  # does this function have a body? (false for interface functions)
+    overrides: bool  # does this function override an interface declaration or super-contract definition?
+    contractName: str
+    ast_id: Optional[int] = None
+    where: Optional[Tuple[str, str]] = None  # 1st element: source file name, 2nd element: location string
 
 
 class CompilerLang(metaclass=AbstractAndSingleton):
@@ -146,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-6.3.1 → 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-6.3.1 → 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-6.3.1 → certora-cli-7.3.0}/certora_cli/EVMVerifier/Compiler/CompilerCollectorVy.py

@@ -80,6 +80,10 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         return {CompilerLangVy.compilation_output_path(sdc_name),
                 CompilerLangVy.compilation_error_path(sdc_name)}
 
+    @staticmethod
+    def pad(x: int) -> int:
+        return (x + 31) & ~31
+
     class VyperType(ABC):
         uniqueId: int = 0
 
@@ -90,11 +94,11 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             return r
 
         @abstractmethod
-        def size_in_bytes(self) -> int:
+        def size_in_bytes(self, storage: bool = False) -> int:
             pass
 
         @abstractmethod
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             """Returns a JSON-style object containing the fields of a [bridge.SolcType] (in kotlin)"""
             pass
 
@@ -126,10 +130,10 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         def __init__(self, name: str):
             self.name = name
 
-        def size_in_bytes(self) -> int:
+        def size_in_bytes(self, storage: bool = False) -> int:
             raise NotImplementedError
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             raise NotImplementedError
 
         def get_canonical_vyper_name(self) -> str:
@@ -154,15 +158,21 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             self.element_type = element_type
             self.max_num_elements = max_num_elements
 
-        def size_in_bytes(self) -> int:
-            return self.element_type.size_in_bytes() * self.max_num_elements
+        def size_in_bytes(self, storage: bool = False) -> int:
+            element_size = self.element_type.size_in_bytes(storage)
+            # bytes _are_ actually packed in storage arrays
+            if storage and self.element_type != CompilerLangVy.primitive_types['byte']:
+                element_size = CompilerLangVy.pad(element_size)
+                return element_size * self.max_num_elements
+            else:
+                return CompilerLangVy.pad(element_size * self.max_num_elements)
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             return {
                 'label': self.get_canonical_vyper_name(),
                 'encoding': 'inplace',
                 'base': self.element_type.get_canonical_vyper_name(),
-                'numberOfBytes': str(self.size_in_bytes())
+                'numberOfBytes': str(self.size_in_bytes(storage))
             }
 
         def get_canonical_vyper_name(self) -> str:
@@ -173,7 +183,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             return self
 
         def get_used_types(self) -> List[Any]:
-            return [self] + [self.element_type]
+            return [self] + self.element_type.get_used_types()
 
         def get_certora_type(self, contract_name: str, ref: int) -> CT.Type:
             return CT.ArrayType(self.element_type.get_canonical_vyper_name(),
@@ -193,14 +203,14 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             self.name    = name
             self.members = members
 
-        def size_in_bytes(self) -> int:
+        def size_in_bytes(self, storage: bool = False) -> int:
             return 1
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             return {
                 'label': self.get_canonical_vyper_name(),
                 'encoding': 'inplace',
-                'numberOfBytes': str(self.size_in_bytes())
+                'numberOfBytes': str(self.size_in_bytes(storage))
             }
 
         def get_canonical_vyper_name(self) -> str:
@@ -227,15 +237,20 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             self.name = name
             self.members = members
 
-        def size_in_bytes(self) -> int:
-            return sum([f[1].size_in_bytes() for f in self.members])
+        def size_in_bytes(self, storage: bool = False) -> int:
+            def mem_size(f: Tuple[str, Any]) -> int:
+                sz = f[1].size_in_bytes(storage)
+                if storage:
+                    sz = CompilerLangVy.pad(sz)
+                return sz
+            return sum([mem_size(f) for f in self.members])
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             bytes_so_far_rounded_up = 0
             slots = {}
             for n, t in self.members:
                 slots.update({n: bytes_so_far_rounded_up // 32})
-                bytes_so_far_rounded_up += (t.size_in_bytes() + 31) & ~31
+                bytes_so_far_rounded_up += CompilerLangVy.pad(t.size_in_bytes(storage))
             members_field = [
                 {
                     'label': n,
@@ -248,7 +263,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
                 'label': self.get_canonical_vyper_name(),
                 'encoding': 'inplace',
                 'members': members_field,
-                'numberOfBytes': str(self.size_in_bytes())
+                'numberOfBytes': str(self.size_in_bytes(storage))
             }
 
         def get_canonical_vyper_name(self) -> str:
@@ -282,12 +297,12 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             self.max_num_elements = max_num_elements
 
             self.count_type = CompilerLangVy.VyperTypeBoundedInteger(
-                CompilerLangVy.primitive_types['uint256'], 1, max_num_elements)
+                CompilerLangVy.primitive_types['uint256'], 0, max_num_elements)
             self.array_type = CompilerLangVy.VyperTypeStaticArray(element_type, int(max_num_elements))
             super().__init__(self.get_canonical_vyper_name(), [('count', self.count_type), ('data', self.array_type)])
 
         def get_canonical_vyper_name(self) -> str:
-            return f"DynArray[{self.element_type.get_canonical_vyper_name()},{self.max_num_elements}]"
+            return f"DynArray[{self.element_type.get_canonical_vyper_name()}, {self.max_num_elements}]"
 
         def get_certora_type(self, contract_name: str, ref: int) -> CT.Type:
             element_type = self.element_type.get_certora_type(contract_name, ref)
@@ -308,15 +323,25 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         def get_certora_type(self, contract_name: str, ref: int) -> CT.Type:
             return CT.StringType()
 
+    class VyperTypeBytes(VyperTypeDynArray):
+        def __init__(self, max_num_elements: int):
+            super().__init__(CompilerLangVy.primitive_types['byte'], max_num_elements)
+
+        def get_canonical_vyper_name(self) -> str:
+            return 'Bytes[' + str(self.array_type.max_num_elements) + ']'
+
+        def get_certora_type(self, contract_name: str, ref: int) -> CT.Type:
+            return CT.PackedBytes()
+
     class VyperTypeHashMap(VyperType):
         def __init__(self, key_type: Any, value_type: Any):
             self.key_type = key_type
             self.value_type = value_type
 
-        def size_in_bytes(self) -> int:
+        def size_in_bytes(self, storage: bool = False) -> int:
             return 32
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             return {
                 'label': self.get_canonical_vyper_name(),
                 'encoding': 'mapping',
@@ -335,7 +360,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             return self
 
         def get_used_types(self) -> List[Any]:
-            return [self] + [self.key_type] + [self.value_type]
+            return [self] + self.key_type.get_used_types() + self.value_type.get_used_types()
 
         def get_certora_type(self, contract_name: str, ref: int) -> CT.Type:
             in_type = self.key_type.get_certora_type(contract_name, ref)
@@ -353,17 +378,17 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         def __init__(self, name: str):
             self.name = name
 
-        def size_in_bytes(self) -> int:
+        def size_in_bytes(self, storage: bool = False) -> int:
             return 20
 
         def get_canonical_vyper_name(self) -> str:
             return self.name
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             return {
                 'label': "contract " + self.get_canonical_vyper_name(),
                 'encoding': 'inplace',
-                'numberOfBytes': str(self.size_in_bytes())
+                'numberOfBytes': str(self.size_in_bytes(storage))
             }
 
         def get_certora_type(self, contract_name: str, ref: int) -> CT.Type:
@@ -380,14 +405,14 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             self.name = name
             self.size = size
 
-        def size_in_bytes(self) -> int:
+        def size_in_bytes(self, storage: bool = False) -> int:
             return self.size
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             return {
                 'label': self.get_canonical_vyper_name(),
                 'encoding': 'inplace',
-                'numberOfBytes': str(self.size_in_bytes())
+                'numberOfBytes': str(self.size_in_bytes(storage))
             }
 
         def get_canonical_vyper_name(self) -> str:
@@ -428,11 +453,11 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
             self.lower_bound = lower_bound
             self.upper_bound = upper_bound
 
-        def generate_types_field(self) -> Dict[str, Any]:
+        def generate_types_field(self, storage: bool = False) -> Dict[str, Any]:
             return {
                 'label': self.get_canonical_vyper_name(),
                 'encoding': 'inplace',
-                'numberOfBytes': str(self.size_in_bytes()),
+                'numberOfBytes': str(self.size_in_bytes(storage)),
                 'lowerBound': str(self.lower_bound),
                 'upperBound': str(self.upper_bound)
             }
@@ -464,6 +489,20 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         **build_sequence(lambda i: f"bytes{i}", lambda i: 32 + i)  # type: ignore
     }
 
+    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:
         """
@@ -509,6 +548,9 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         if value_id == 'String':
             max_bytes = ast_subscript_node['slice']['value']['value']
             return CompilerLangVy.VyperTypeString(max_bytes)
+        elif value_id == 'Bytes':
+            max_bytes = ast_subscript_node['slice']['value']['value']
+            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)
@@ -626,18 +668,23 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         decorators = [dec['id'] for dec in function_def['decorator_list'] if 'id' in dec]  # ignores Call decorators
 
         result = []
+        is_constructor = function_def['name'] == CompilerLangVy.vyper_constructor_name
         for args in arg_variants:
             arg_names, arg_types = [n for n, t in args], [t for n, t in args]  # python's not smart enough to type `zip`
+            if not is_constructor:
+                func_selector = CompilerLangVy.get_function_selector(function_def['name'], arg_types, is_lib=False)
+            else:
+                func_selector = "0"  # this is the sighash for constructors in Solidity too
             result.append(CompilerLangFunc(
                 name            = function_def['name'],
-                fullargs        = arg_types,
-                paramnames      = arg_names,
+                fullArgs        = arg_types,
+                paramNames      = arg_names,
                 returns         = ret_types,
-                sighash         = CompilerLangVy.get_function_selector(function_def['name'], arg_types, is_lib=False),
+                sighash         = func_selector,
                 notpayable      = "payable" not in decorators,
-                fromlib         = False,
-                isconstructor   = function_def['name'] == "__init__",
-                statemutability = first_of(decorators, ["pure", "view", "payable"], default="nonpayable"),
+                fromLib         = False,
+                isConstructor   = is_constructor,
+                stateMutability = first_of(decorators, ["pure", "view", "payable"], default="nonpayable"),
                 implemented     = True,
                 overrides       = False,
                 visibility      = first_of(decorators, ["internal", "external"]),
@@ -656,14 +703,14 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
 
         return CompilerLangFunc(
             name            = var_name,
-            fullargs        = arg_types,
-            paramnames      = [],
+            fullArgs        = arg_types,
+            paramNames      = [],
             returns         = ret_types,
             sighash         = CompilerLangVy.get_function_selector(var_name, arg_types, is_lib=False),
             notpayable      = True,
-            fromlib         = False,
-            isconstructor   = False,
-            statemutability = "view",
+            fromLib         = False,
+            isConstructor   = False,
+            stateMutability = "view",
             implemented     = True,
             overrides       = False,
             visibility      = "external",
@@ -699,15 +746,22 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
         result_types = []
         public_vardecls = {}
         named_constants: Dict[str, int] = {}
+
+        # Process named constants ahead of time, as their use site in the source may precede
+        # their definition site, e.g.
+        for ast_node in ast_body_nodes.values():
+            if ast_node['ast_type'] != 'VariableDecl':
+                continue
+            if ast_node['is_constant'] and ast_node['value'] is not None and \
+               (ast_node['value']['ast_type'] == 'Int'):
+                named_constants.update({ast_node['target']['id']: int(ast_node['value']['value'])})
+
         for ast_node in ast_body_nodes.values():
             if ast_node['ast_type'] == 'VariableDecl':
                 decltype = CompilerLangVy.extract_type_from_variable_decl(ast_node, named_constants)
                 result_types.append(decltype)
                 if ast_node['is_public']:
                     public_vardecls[ast_node['target']['id']] = decltype
-                if ast_node['is_constant'] and (ast_node['value'] is not None) and \
-                        (ast_node['value']['ast_type'] == 'Int'):
-                    named_constants.update({ast_node['target']['id']: int(ast_node['value']['value'])})
             elif ast_node['ast_type'] == 'StructDef':
                 result_types.append(CompilerLangVy.extract_type_from_struct_def(ast_node, named_constants))
             # Not sure if `Import` is an actual ast type. It was already there, so I am not removing it.
@@ -791,7 +845,7 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
                 list(CompilerLangVy.primitive_types.values())
             type_descriptors_by_name = {i.get_canonical_vyper_name(): i.get_storage_type_descriptor()
                                         for i in all_used_types}
-            types_field = {i.get_canonical_vyper_name(): i.generate_types_field() for i in all_used_types}
+            types_field = {i.get_canonical_vyper_name(): i.generate_types_field(storage=True) for i in all_used_types}
 
             def annotate_desc(desc: Dict[Any, Any], type_name: str, all_types: Dict[Any, Any], slot: Any = None,
                               offset: Any = None) -> Dict[Any, Any]:
@@ -968,20 +1022,24 @@ class CompilerLangVy(CompilerLang, metaclass=Singleton):
                             solidity_type_args = [get_solidity_type_from_abi(p) for p in params]
                             solidity_type_outs = [get_solidity_type_from_abi(p) for p in out_params]
 
-                        func_selector = get_function_selector({}, name, solidity_type_args, True)
+                        is_constructor = name == CompilerLangVy.vyper_constructor_name
+                        if not is_constructor:
+                            func_selector = get_function_selector({}, name, solidity_type_args, True)
+                        else:
+                            func_selector = "0"  # this is the sighash for constructors in Solidity too
                         state_mutability = abi_data["stateMutability"]
 
                         funcs.append(
                             CompilerLangFunc(
                                 name=name,
-                                fullargs=solidity_type_args,
-                                paramnames=[],
+                                fullArgs=solidity_type_args,
+                                paramNames=[],
                                 returns=solidity_type_outs,
                                 sighash=func_selector,
                                 notpayable=state_mutability in ["nonpayable", "view", "pure"],
-                                fromlib=False,
-                                isconstructor=False,
-                                statemutability=state_mutability,
+                                fromLib=False,
+                                isConstructor=is_constructor,
+                                stateMutability=state_mutability,
                                 implemented=True,
                                 overrides=False,
                                 # according to Solidity docs, getter functions have external visibility