slither.core.declarations.contract

   1""""
   2    Contract module
   3"""
   4import logging
   5from collections import defaultdict
   6from pathlib import Path
   7from typing import Optional, List, Dict, Callable, Tuple, TYPE_CHECKING, Union, Set, Any
   8
   9from crytic_compile.platform import Type as PlatformType
  10
  11from slither.core.cfg.scope import Scope
  12from slither.core.source_mapping.source_mapping import SourceMapping
  13from slither.utils.using_for import USING_FOR, merge_using_for
  14from slither.core.declarations.function import Function, FunctionType, FunctionLanguage
  15from slither.utils.erc import (
  16    ERC20_signatures,
  17    ERC165_signatures,
  18    ERC223_signatures,
  19    ERC721_signatures,
  20    ERC1820_signatures,
  21    ERC777_signatures,
  22    ERC1155_signatures,
  23    ERC2612_signatures,
  24    ERC1363_signatures,
  25    ERC4524_signatures,
  26    ERC4626_signatures,
  27)
  28from slither.utils.tests_pattern import is_test_contract
  29
  30# pylint: disable=too-many-lines,too-many-instance-attributes,import-outside-toplevel,too-many-nested-blocks
  31if TYPE_CHECKING:
  32    from slither.core.declarations import (
  33        Enum,
  34        EventContract,
  35        Modifier,
  36        EnumContract,
  37        StructureContract,
  38        FunctionContract,
  39        CustomErrorContract,
  40    )
  41    from slither.slithir.operations import HighLevelCall, LibraryCall
  42    from slither.slithir.variables.variable import SlithIRVariable
  43    from slither.core.variables import Variable, StateVariable
  44    from slither.core.compilation_unit import SlitherCompilationUnit
  45    from slither.core.scope.scope import FileScope
  46    from slither.core.cfg.node import Node
  47    from slither.core.solidity_types import TypeAliasContract
  48
  49
  50LOGGER = logging.getLogger("Contract")
  51
  52
  53class Contract(SourceMapping):  # pylint: disable=too-many-public-methods
  54    """
  55    Contract class
  56    """
  57
  58    def __init__(self, compilation_unit: "SlitherCompilationUnit", scope: "FileScope") -> None:
  59        super().__init__()
  60
  61        self._name: Optional[str] = None
  62        self._id: Optional[int] = None
  63        self._inheritance: List["Contract"] = []  # all contract inherited, c3 linearization
  64        self._immediate_inheritance: List["Contract"] = []  # immediate inheritance
  65
  66        # Constructors called on contract's definition
  67        # contract B is A(1) { ..
  68        self._explicit_base_constructor_calls: List["Contract"] = []
  69
  70        self._enums: Dict[str, "EnumContract"] = {}
  71        self._structures: Dict[str, "StructureContract"] = {}
  72        self._events: Dict[str, "EventContract"] = {}
  73        # map accessible variable from name -> variable
  74        # do not contain private variables inherited from contract
  75        self._variables: Dict[str, "StateVariable"] = {}
  76        self._variables_ordered: List["StateVariable"] = []
  77        # Reference id -> variable declaration (only available for compact AST)
  78        self._state_variables_by_ref_id: Dict[int, "StateVariable"] = {}
  79        self._modifiers: Dict[str, "Modifier"] = {}
  80        self._functions: Dict[str, "FunctionContract"] = {}
  81        self._linearizedBaseContracts: List[int] = []
  82        self._custom_errors: Dict[str, "CustomErrorContract"] = {}
  83        self._type_aliases: Dict[str, "TypeAliasContract"] = {}
  84
  85        # The only str is "*"
  86        self._using_for: USING_FOR = {}
  87        self._using_for_complete: Optional[USING_FOR] = None
  88        self._kind: Optional[str] = None
  89        self._is_interface: bool = False
  90        self._is_library: bool = False
  91        self._is_fully_implemented: bool = False
  92        self._is_abstract: bool = False
  93
  94        self._signatures: Optional[List[str]] = None
  95        self._signatures_declared: Optional[List[str]] = None
  96
  97        self._fallback_function: Optional["FunctionContract"] = None
  98        self._receive_function: Optional["FunctionContract"] = None
  99
 100        self._is_upgradeable: Optional[bool] = None
 101        self._is_upgradeable_proxy: Optional[bool] = None
 102        self._upgradeable_version: Optional[str] = None
 103
 104        self._initial_state_variables: List["StateVariable"] = []  # ssa
 105
 106        self._is_incorrectly_parsed: bool = False
 107
 108        self._available_functions_as_dict: Optional[Dict[str, "Function"]] = None
 109        self._all_functions_called: Optional[List["Function"]] = None
 110
 111        self.compilation_unit: "SlitherCompilationUnit" = compilation_unit
 112        self.file_scope: "FileScope" = scope
 113
 114        # memoize
 115        self._state_variables_used_in_reentrant_targets: Optional[
 116            Dict["StateVariable", Set[Union["StateVariable", "Function"]]]
 117        ] = None
 118
 119        self._comments: Optional[str] = None
 120
 121    ###################################################################################
 122    ###################################################################################
 123    # region General's properties
 124    ###################################################################################
 125    ###################################################################################
 126
 127    @property
 128    def name(self) -> str:
 129        """str: Name of the contract."""
 130        assert self._name
 131        return self._name
 132
 133    @name.setter
 134    def name(self, name: str) -> None:
 135        self._name = name
 136
 137    @property
 138    def id(self) -> int:
 139        """Unique id."""
 140        assert self._id is not None
 141        return self._id
 142
 143    @id.setter
 144    def id(self, new_id: int) -> None:
 145        """Unique id."""
 146        self._id = new_id
 147
 148    @property
 149    def contract_kind(self) -> Optional[str]:
 150        """
 151        contract_kind can be None if the legacy ast format is used
 152        :return:
 153        """
 154        return self._kind
 155
 156    @contract_kind.setter
 157    def contract_kind(self, kind: str) -> None:
 158        self._kind = kind
 159
 160    @property
 161    def is_interface(self) -> bool:
 162        return self._is_interface
 163
 164    @is_interface.setter
 165    def is_interface(self, is_interface: bool) -> None:
 166        self._is_interface = is_interface
 167
 168    @property
 169    def is_library(self) -> bool:
 170        return self._is_library
 171
 172    @is_library.setter
 173    def is_library(self, is_library: bool) -> None:
 174        self._is_library = is_library
 175
 176    @property
 177    def comments(self) -> Optional[str]:
 178        """
 179        Return the comments associated with the contract.
 180
 181        When using comments, avoid strict text matching, as the solc behavior might change.
 182        For example, for old solc version, the first space after the * is not kept, i.e:
 183
 184          * @title Test Contract
 185          * @dev Test comment
 186
 187        Returns
 188        - " @title Test Contract\n @dev Test comment" for newest versions
 189        - "@title Test Contract\n@dev Test comment" for older versions
 190
 191
 192        Returns:
 193            the comment as a string
 194        """
 195        return self._comments
 196
 197    @comments.setter
 198    def comments(self, comments: str):
 199        self._comments = comments
 200
 201    @property
 202    def is_fully_implemented(self) -> bool:
 203        """
 204        bool: True if the contract defines all functions.
 205        In modern Solidity, virtual functions can lack an implementation.
 206        Prior to Solidity 0.6.0, functions like the following would be not fully implemented:
 207        ```solidity
 208        contract ImplicitAbstract{
 209            function f() public;
 210        }
 211        ```
 212        """
 213        return self._is_fully_implemented
 214
 215    @is_fully_implemented.setter
 216    def is_fully_implemented(self, is_fully_implemented: bool):
 217        self._is_fully_implemented = is_fully_implemented
 218
 219    @property
 220    def is_abstract(self) -> bool:
 221        """
 222        Note for Solidity < 0.6.0 it will always be false
 223        bool: True if the contract is abstract.
 224        """
 225        return self._is_abstract
 226
 227    @is_abstract.setter
 228    def is_abstract(self, is_abstract: bool):
 229        self._is_abstract = is_abstract
 230
 231    # endregion
 232    ###################################################################################
 233    ###################################################################################
 234    # region Structures
 235    ###################################################################################
 236    ###################################################################################
 237
 238    @property
 239    def structures(self) -> List["StructureContract"]:
 240        """
 241        list(Structure): List of the structures
 242        """
 243        return list(self._structures.values())
 244
 245    @property
 246    def structures_inherited(self) -> List["StructureContract"]:
 247        """
 248        list(Structure): List of the inherited structures
 249        """
 250        return [s for s in self.structures if s.contract != self]
 251
 252    @property
 253    def structures_declared(self) -> List["StructureContract"]:
 254        """
 255        list(Structues): List of the structures declared within the contract (not inherited)
 256        """
 257        return [s for s in self.structures if s.contract == self]
 258
 259    @property
 260    def structures_as_dict(self) -> Dict[str, "StructureContract"]:
 261        return self._structures
 262
 263    # endregion
 264    ###################################################################################
 265    ###################################################################################
 266    # region Enums
 267    ###################################################################################
 268    ###################################################################################
 269
 270    @property
 271    def enums(self) -> List["EnumContract"]:
 272        return list(self._enums.values())
 273
 274    @property
 275    def enums_inherited(self) -> List["EnumContract"]:
 276        """
 277        list(Enum): List of the inherited enums
 278        """
 279        return [e for e in self.enums if e.contract != self]
 280
 281    @property
 282    def enums_declared(self) -> List["EnumContract"]:
 283        """
 284        list(Enum): List of the enums declared within the contract (not inherited)
 285        """
 286        return [e for e in self.enums if e.contract == self]
 287
 288    @property
 289    def enums_as_dict(self) -> Dict[str, "EnumContract"]:
 290        return self._enums
 291
 292    # endregion
 293    ###################################################################################
 294    ###################################################################################
 295    # region Events
 296    ###################################################################################
 297    ###################################################################################
 298
 299    @property
 300    def events(self) -> List["EventContract"]:
 301        """
 302        list(Event): List of the events
 303        """
 304        return list(self._events.values())
 305
 306    @property
 307    def events_inherited(self) -> List["EventContract"]:
 308        """
 309        list(Event): List of the inherited events
 310        """
 311        return [e for e in self.events if e.contract != self]
 312
 313    @property
 314    def events_declared(self) -> List["EventContract"]:
 315        """
 316        list(Event): List of the events declared within the contract (not inherited)
 317        """
 318        return [e for e in self.events if e.contract == self]
 319
 320    @property
 321    def events_as_dict(self) -> Dict[str, "EventContract"]:
 322        return self._events
 323
 324    # endregion
 325    ###################################################################################
 326    ###################################################################################
 327    # region Using for
 328    ###################################################################################
 329    ###################################################################################
 330
 331    @property
 332    def using_for(self) -> USING_FOR:
 333        return self._using_for
 334
 335    @property
 336    def using_for_complete(self) -> USING_FOR:
 337        """
 338        USING_FOR: Dict of merged local using for directive with top level directive
 339        """
 340
 341        if self._using_for_complete is None:
 342            result = self.using_for
 343            top_level_using_for = self.file_scope.using_for_directives
 344            for uftl in top_level_using_for:
 345                result = merge_using_for(result, uftl.using_for)
 346            self._using_for_complete = result
 347        return self._using_for_complete
 348
 349    # endregion
 350    ###################################################################################
 351    ###################################################################################
 352    # region Custom Errors
 353    ###################################################################################
 354    ###################################################################################
 355
 356    @property
 357    def custom_errors(self) -> List["CustomErrorContract"]:
 358        """
 359        list(CustomErrorContract): List of the contract's custom errors
 360        """
 361        return list(self._custom_errors.values())
 362
 363    @property
 364    def custom_errors_inherited(self) -> List["CustomErrorContract"]:
 365        """
 366        list(CustomErrorContract): List of the inherited custom errors
 367        """
 368        return [s for s in self.custom_errors if s.contract != self]
 369
 370    @property
 371    def custom_errors_declared(self) -> List["CustomErrorContract"]:
 372        """
 373        list(CustomErrorContract): List of the custom errors declared within the contract (not inherited)
 374        """
 375        return [s for s in self.custom_errors if s.contract == self]
 376
 377    @property
 378    def custom_errors_as_dict(self) -> Dict[str, "CustomErrorContract"]:
 379        return self._custom_errors
 380
 381    # endregion
 382    ###################################################################################
 383    ###################################################################################
 384    # region Custom Errors
 385    ###################################################################################
 386    ###################################################################################
 387
 388    @property
 389    def type_aliases(self) -> List["TypeAliasContract"]:
 390        """
 391        list(TypeAliasContract): List of the contract's custom errors
 392        """
 393        return list(self._type_aliases.values())
 394
 395    @property
 396    def type_aliases_inherited(self) -> List["TypeAliasContract"]:
 397        """
 398        list(TypeAliasContract): List of the inherited custom errors
 399        """
 400        return [s for s in self.type_aliases if s.contract != self]
 401
 402    @property
 403    def type_aliases_declared(self) -> List["TypeAliasContract"]:
 404        """
 405        list(TypeAliasContract): List of the custom errors declared within the contract (not inherited)
 406        """
 407        return [s for s in self.type_aliases if s.contract == self]
 408
 409    @property
 410    def type_aliases_as_dict(self) -> Dict[str, "TypeAliasContract"]:
 411        return self._type_aliases
 412
 413    # endregion
 414    ###################################################################################
 415    ###################################################################################
 416    # region Variables
 417    ###################################################################################
 418    ###################################################################################
 419    @property
 420    def state_variables_by_ref_id(self) -> Dict[int, "StateVariable"]:
 421        """
 422        Returns the state variables by reference id (only available for compact AST).
 423        """
 424        return self._state_variables_by_ref_id
 425
 426    @property
 427    def variables(self) -> List["StateVariable"]:
 428        """
 429        Returns all the accessible variables (do not include private variable from inherited contract)
 430
 431        list(StateVariable): List of the state variables. Alias to self.state_variables.
 432        """
 433        return list(self.state_variables)
 434
 435    @property
 436    def variables_as_dict(self) -> Dict[str, "StateVariable"]:
 437        return self._variables
 438
 439    @property
 440    def state_variables(self) -> List["StateVariable"]:
 441        """
 442        Returns all the accessible variables (do not include private variable from inherited contract).
 443        Use stored_state_variables_ordered for all the storage variables following the storage order
 444        Use transient_state_variables_ordered for all the transient variables following the storage order
 445
 446        list(StateVariable): List of the state variables.
 447        """
 448        return list(self._variables.values())
 449
 450    @property
 451    def state_variables_entry_points(self) -> List["StateVariable"]:
 452        """
 453        list(StateVariable): List of the state variables that are public.
 454        """
 455        return [var for var in self._variables.values() if var.visibility == "public"]
 456
 457    @property
 458    def state_variables_ordered(self) -> List["StateVariable"]:
 459        """
 460        list(StateVariable): List of the state variables by order of declaration.
 461        """
 462        return self._variables_ordered
 463
 464    def add_state_variables_ordered(self, new_vars: List["StateVariable"]) -> None:
 465        self._variables_ordered += new_vars
 466
 467    @property
 468    def storage_variables_ordered(self) -> List["StateVariable"]:
 469        """
 470        list(StateVariable): List of the state variables in storage location by order of declaration.
 471        """
 472        return [v for v in self._variables_ordered if v.is_stored]
 473
 474    @property
 475    def transient_variables_ordered(self) -> List["StateVariable"]:
 476        """
 477        list(StateVariable): List of the state variables in transient location by order of declaration.
 478        """
 479        return [v for v in self._variables_ordered if v.is_transient]
 480
 481    @property
 482    def state_variables_inherited(self) -> List["StateVariable"]:
 483        """
 484        list(StateVariable): List of the inherited state variables
 485        """
 486        return [s for s in self.state_variables if s.contract != self]
 487
 488    @property
 489    def state_variables_declared(self) -> List["StateVariable"]:
 490        """
 491        list(StateVariable): List of the state variables declared within the contract (not inherited)
 492        """
 493        return [s for s in self.state_variables if s.contract == self]
 494
 495    @property
 496    def slithir_variables(self) -> List["SlithIRVariable"]:
 497        """
 498        List all of the slithir variables (non SSA)
 499        """
 500        slithir_variabless = [f.slithir_variables for f in self.functions + self.modifiers]  # type: ignore
 501        slithir_variables = [item for sublist in slithir_variabless for item in sublist]
 502        return list(set(slithir_variables))
 503
 504    @property
 505    def state_variables_used_in_reentrant_targets(
 506        self,
 507    ) -> Dict["StateVariable", Set[Union["StateVariable", "Function"]]]:
 508        """
 509        Returns the state variables used in reentrant targets. Heuristics:
 510        - Variable used (read/write) in entry points that are reentrant
 511        - State variables that are public
 512
 513        """
 514        from slither.core.variables.state_variable import StateVariable
 515
 516        if self._state_variables_used_in_reentrant_targets is None:
 517            reentrant_functions = [f for f in self.functions_entry_points if f.is_reentrant]
 518            variables_used: Dict[
 519                StateVariable, Set[Union[StateVariable, "Function"]]
 520            ] = defaultdict(set)
 521            for function in reentrant_functions:
 522                for ir in function.all_slithir_operations():
 523                    state_variables = [v for v in ir.used if isinstance(v, StateVariable)]
 524                    for state_variable in state_variables:
 525                        variables_used[state_variable].add(ir.node.function)
 526            for variable in [v for v in self.state_variables if v.visibility == "public"]:
 527                variables_used[variable].add(variable)
 528            self._state_variables_used_in_reentrant_targets = variables_used
 529        return self._state_variables_used_in_reentrant_targets
 530
 531    # endregion
 532    ###################################################################################
 533    ###################################################################################
 534    # region Constructors
 535    ###################################################################################
 536    ###################################################################################
 537
 538    @property
 539    def constructor(self) -> Optional["Function"]:
 540        """
 541        Return the contract's immediate constructor.
 542        If there is no immediate constructor, returns the first constructor
 543        executed, following the c3 linearization
 544        Return None if there is no constructor.
 545        """
 546        cst = self.constructors_declared
 547        if cst:
 548            return cst
 549        for inherited_contract in self.inheritance:
 550            cst = inherited_contract.constructors_declared
 551            if cst:
 552                return cst
 553        return None
 554
 555    @property
 556    def constructors_declared(self) -> Optional["Function"]:
 557        return next(
 558            (
 559                func
 560                for func in self.functions
 561                if func.is_constructor and func.contract_declarer == self
 562            ),
 563            None,
 564        )
 565
 566    @property
 567    def constructors(self) -> List["FunctionContract"]:
 568        """
 569        Return the list of constructors (including inherited)
 570        """
 571        return [func for func in self.functions if func.is_constructor]
 572
 573    @property
 574    def explicit_base_constructor_calls(self) -> List["Function"]:
 575        """
 576        list(Function): List of the base constructors called explicitly by this contract definition.
 577
 578                        Base constructors called by any constructor definition will not be included.
 579                        Base constructors implicitly called by the contract definition (without
 580                        parenthesis) will not be included.
 581
 582                        On "contract B is A(){..}" it returns the constructor of A
 583        """
 584        return [c.constructor for c in self._explicit_base_constructor_calls if c.constructor]
 585
 586    # endregion
 587    ###################################################################################
 588    ###################################################################################
 589    # region Functions and Modifiers
 590    ###################################################################################
 591    ###################################################################################
 592
 593    @property
 594    def functions_signatures(self) -> List[str]:
 595        """
 596        Return the signatures of all the public/eterxnal functions/state variables
 597        :return: list(string) the signatures of all the functions that can be called
 598        """
 599        if self._signatures is None:
 600            sigs = [
 601                v.full_name for v in self.state_variables if v.visibility in ["public", "external"]
 602            ]
 603
 604            sigs += {f.full_name for f in self.functions if f.visibility in ["public", "external"]}
 605            self._signatures = list(set(sigs))
 606        return self._signatures
 607
 608    @property
 609    def functions_signatures_declared(self) -> List[str]:
 610        """
 611        Return the signatures of the public/eterxnal functions/state variables that are declared by this contract
 612        :return: list(string) the signatures of all the functions that can be called and are declared by this contract
 613        """
 614        if self._signatures_declared is None:
 615            sigs = [
 616                v.full_name
 617                for v in self.state_variables_declared
 618                if v.visibility in ["public", "external"]
 619            ]
 620
 621            sigs += {
 622                f.full_name
 623                for f in self.functions_declared
 624                if f.visibility in ["public", "external"]
 625            }
 626            self._signatures_declared = list(set(sigs))
 627        return self._signatures_declared
 628
 629    @property
 630    def functions(self) -> List["FunctionContract"]:
 631        """
 632        list(Function): List of the functions
 633        """
 634        return list(self._functions.values())
 635
 636    def available_functions_as_dict(self) -> Dict[str, "Function"]:
 637        if self._available_functions_as_dict is None:
 638            self._available_functions_as_dict = {
 639                f.full_name: f for f in self._functions.values() if not f.is_shadowed
 640            }
 641        return self._available_functions_as_dict
 642
 643    def add_function(self, func: "FunctionContract") -> None:
 644        self._functions[func.canonical_name] = func
 645
 646    def set_functions(self, functions: Dict[str, "FunctionContract"]) -> None:
 647        """
 648        Set the functions
 649
 650        :param functions:  dict full_name -> function
 651        :return:
 652        """
 653        self._functions = functions
 654
 655    @property
 656    def functions_inherited(self) -> List["FunctionContract"]:
 657        """
 658        list(Function): List of the inherited functions
 659        """
 660        return [f for f in self.functions if f.contract_declarer != self]
 661
 662    @property
 663    def functions_declared(self) -> List["FunctionContract"]:
 664        """
 665        list(Function): List of the functions defined within the contract (not inherited)
 666        """
 667        return [f for f in self.functions if f.contract_declarer == self]
 668
 669    @property
 670    def functions_entry_points(self) -> List["FunctionContract"]:
 671        """
 672        list(Functions): List of public and external functions
 673        """
 674        return [
 675            f
 676            for f in self.functions
 677            if f.visibility in ["public", "external"] and not f.is_shadowed or f.is_fallback
 678        ]
 679
 680    @property
 681    def modifiers(self) -> List["Modifier"]:
 682        """
 683        list(Modifier): List of the modifiers
 684        """
 685        return list(self._modifiers.values())
 686
 687    def available_modifiers_as_dict(self) -> Dict[str, "Modifier"]:
 688        return {m.full_name: m for m in self._modifiers.values() if not m.is_shadowed}
 689
 690    def set_modifiers(self, modifiers: Dict[str, "Modifier"]) -> None:
 691        """
 692        Set the modifiers
 693
 694        :param modifiers:  dict full_name -> modifier
 695        :return:
 696        """
 697        self._modifiers = modifiers
 698
 699    @property
 700    def modifiers_inherited(self) -> List["Modifier"]:
 701        """
 702        list(Modifier): List of the inherited modifiers
 703        """
 704        return [m for m in self.modifiers if m.contract_declarer != self]
 705
 706    @property
 707    def modifiers_declared(self) -> List["Modifier"]:
 708        """
 709        list(Modifier): List of the modifiers defined within the contract (not inherited)
 710        """
 711        return [m for m in self.modifiers if m.contract_declarer == self]
 712
 713    @property
 714    def functions_and_modifiers(self) -> List["Function"]:
 715        """
 716        list(Function|Modifier): List of the functions and modifiers
 717        """
 718        return self.functions + self.modifiers  # type: ignore
 719
 720    @property
 721    def functions_and_modifiers_inherited(self) -> List["Function"]:
 722        """
 723        list(Function|Modifier): List of the inherited functions and modifiers
 724        """
 725        return self.functions_inherited + self.modifiers_inherited  # type: ignore
 726
 727    @property
 728    def functions_and_modifiers_declared(self) -> List["Function"]:
 729        """
 730        list(Function|Modifier): List of the functions and modifiers defined within the contract (not inherited)
 731        """
 732        return self.functions_declared + self.modifiers_declared  # type: ignore
 733
 734    @property
 735    def fallback_function(self) -> Optional["FunctionContract"]:
 736        if self._fallback_function is None:
 737            for f in self.functions:
 738                if f.is_fallback:
 739                    self._fallback_function = f
 740                    break
 741        return self._fallback_function
 742
 743    @property
 744    def receive_function(self) -> Optional["FunctionContract"]:
 745        if self._receive_function is None:
 746            for f in self.functions:
 747                if f.is_receive:
 748                    self._receive_function = f
 749                    break
 750        return self._receive_function
 751
 752    def available_elements_from_inheritances(
 753        self,
 754        elements: Dict[str, "Function"],
 755        getter_available: Callable[["Contract"], List["FunctionContract"]],
 756    ) -> Dict[str, "Function"]:
 757        """
 758
 759        :param elements: dict(canonical_name -> elements)
 760        :param getter_available: fun x
 761        :return:
 762        """
 763        # keep track of the contracts visited
 764        # to prevent an ovveride due to multiple inheritance of the same contract
 765        # A is B, C, D is C, --> the second C was already seen
 766        inherited_elements: Dict[str, "FunctionContract"] = {}
 767        accessible_elements = {}
 768        contracts_visited = []
 769        for father in self.inheritance_reverse:
 770            functions: Dict[str, "FunctionContract"] = {
 771                v.full_name: v
 772                for v in getter_available(father)
 773                if v.contract not in contracts_visited
 774                and v.function_language
 775                != FunctionLanguage.Yul  # Yul functions are not propagated in the inheritance
 776            }
 777            contracts_visited.append(father)
 778            inherited_elements.update(functions)
 779
 780        for element in inherited_elements.values():
 781            accessible_elements[element.full_name] = elements[element.canonical_name]
 782
 783        return accessible_elements
 784
 785    # endregion
 786    ###################################################################################
 787    ###################################################################################
 788    # region Inheritance
 789    ###################################################################################
 790    ###################################################################################
 791
 792    @property
 793    def inheritance(self) -> List["Contract"]:
 794        """
 795        list(Contract): Inheritance list. Order: the first elem is the first father to be executed
 796        """
 797        return list(self._inheritance)
 798
 799    @property
 800    def immediate_inheritance(self) -> List["Contract"]:
 801        """
 802        list(Contract): List of contracts immediately inherited from (fathers). Order: order of declaration.
 803        """
 804        return list(self._immediate_inheritance)
 805
 806    @property
 807    def inheritance_reverse(self) -> List["Contract"]:
 808        """
 809        list(Contract): Inheritance list. Order: the last elem is the first father to be executed
 810        """
 811        return list(reversed(self._inheritance))
 812
 813    def set_inheritance(
 814        self,
 815        inheritance: List["Contract"],
 816        immediate_inheritance: List["Contract"],
 817        called_base_constructor_contracts: List["Contract"],
 818    ) -> None:
 819        self._inheritance = inheritance
 820        self._immediate_inheritance = immediate_inheritance
 821        self._explicit_base_constructor_calls = called_base_constructor_contracts
 822
 823    @property
 824    def derived_contracts(self) -> List["Contract"]:
 825        """
 826        list(Contract): Return the list of contracts derived from self
 827        """
 828        candidates = self.compilation_unit.contracts
 829        return [c for c in candidates if self in c.inheritance]  # type: ignore
 830
 831    # endregion
 832    ###################################################################################
 833    ###################################################################################
 834    # region Getters from/to object
 835    ###################################################################################
 836    ###################################################################################
 837
 838    def get_functions_reading_from_variable(self, variable: "Variable") -> List["Function"]:
 839        """
 840        Return the functions reading the variable
 841        """
 842        return [f for f in self.functions if f.is_reading(variable)]
 843
 844    def get_functions_writing_to_variable(self, variable: "Variable") -> List["Function"]:
 845        """
 846        Return the functions writting the variable
 847        """
 848        return [f for f in self.functions if f.is_writing(variable)]
 849
 850    def get_function_from_full_name(self, full_name: str) -> Optional["Function"]:
 851        """
 852            Return a function from a full name
 853            The full name differs from the solidity's signature are the type are conserved
 854            For example contract type are kept, structure are not unrolled, etc
 855        Args:
 856            full_name (str): signature of the function (without return statement)
 857        Returns:
 858            Function
 859        """
 860        return next(
 861            (f for f in self.functions if f.full_name == full_name and not f.is_shadowed),
 862            None,
 863        )
 864
 865    def get_function_from_signature(self, function_signature: str) -> Optional["Function"]:
 866        """
 867            Return a function from a signature
 868        Args:
 869            function_signature (str): signature of the function (without return statement)
 870        Returns:
 871            Function
 872        """
 873        return next(
 874            (
 875                f
 876                for f in self.functions
 877                if f.solidity_signature == function_signature and not f.is_shadowed
 878            ),
 879            None,
 880        )
 881
 882    def get_modifier_from_signature(self, modifier_signature: str) -> Optional["Modifier"]:
 883        """
 884        Return a modifier from a signature
 885
 886        :param modifier_signature:
 887        """
 888        return next(
 889            (m for m in self.modifiers if m.full_name == modifier_signature and not m.is_shadowed),
 890            None,
 891        )
 892
 893    def get_function_from_canonical_name(self, canonical_name: str) -> Optional["Function"]:
 894        """
 895            Return a function from a canonical name (contract.signature())
 896        Args:
 897            canonical_name (str): canonical name of the function (without return statement)
 898        Returns:
 899            Function
 900        """
 901        return next((f for f in self.functions if f.canonical_name == canonical_name), None)
 902
 903    def get_modifier_from_canonical_name(self, canonical_name: str) -> Optional["Modifier"]:
 904        """
 905            Return a modifier from a canonical name (contract.signature())
 906        Args:
 907            canonical_name (str): canonical name of the modifier
 908        Returns:
 909            Modifier
 910        """
 911        return next((m for m in self.modifiers if m.canonical_name == canonical_name), None)
 912
 913    def get_state_variable_from_name(self, variable_name: str) -> Optional["StateVariable"]:
 914        """
 915        Return a state variable from a name
 916
 917        :param variable_name:
 918        """
 919        return next((v for v in self.state_variables if v.name == variable_name), None)
 920
 921    def get_state_variable_from_canonical_name(
 922        self, canonical_name: str
 923    ) -> Optional["StateVariable"]:
 924        """
 925            Return a state variable from a canonical_name
 926        Args:
 927            canonical_name (str): name of the variable
 928        Returns:
 929            StateVariable
 930        """
 931        return next((v for v in self.state_variables if v.canonical_name == canonical_name), None)
 932
 933    def get_structure_from_name(self, structure_name: str) -> Optional["StructureContract"]:
 934        """
 935            Return a structure from a name
 936        Args:
 937            structure_name (str): name of the structure
 938        Returns:
 939            StructureContract
 940        """
 941        return next((st for st in self.structures if st.name == structure_name), None)
 942
 943    def get_structure_from_canonical_name(
 944        self, structure_name: str
 945    ) -> Optional["StructureContract"]:
 946        """
 947            Return a structure from a canonical name
 948        Args:
 949            structure_name (str): canonical name of the structure
 950        Returns:
 951            StructureContract
 952        """
 953        return next((st for st in self.structures if st.canonical_name == structure_name), None)
 954
 955    def get_event_from_signature(self, event_signature: str) -> Optional["Event"]:
 956        """
 957            Return an event from a signature
 958        Args:
 959            event_signature (str): signature of the event
 960        Returns:
 961            Event
 962        """
 963        return next((e for e in self.events if e.full_name == event_signature), None)
 964
 965    def get_event_from_canonical_name(self, event_canonical_name: str) -> Optional["Event"]:
 966        """
 967            Return an event from a canonical name
 968        Args:
 969            event_canonical_name (str): name of the event
 970        Returns:
 971            Event
 972        """
 973        return next((e for e in self.events if e.canonical_name == event_canonical_name), None)
 974
 975    def get_enum_from_name(self, enum_name: str) -> Optional["Enum"]:
 976        """
 977            Return an enum from a name
 978        Args:
 979            enum_name (str): name of the enum
 980        Returns:
 981            Enum
 982        """
 983        return next((e for e in self.enums if e.name == enum_name), None)
 984
 985    def get_enum_from_canonical_name(self, enum_name: str) -> Optional["Enum"]:
 986        """
 987            Return an enum from a canonical name
 988        Args:
 989            enum_name (str): canonical name of the enum
 990        Returns:
 991            Enum
 992        """
 993        return next((e for e in self.enums if e.canonical_name == enum_name), None)
 994
 995    def get_functions_overridden_by(self, function: "Function") -> List["Function"]:
 996        """
 997            Return the list of functions overridden by the function
 998        Args:
 999            (core.Function)
1000        Returns:
1001            list(core.Function)
1002
1003        """
1004        return function.overrides
1005
1006    # endregion
1007    ###################################################################################
1008    ###################################################################################
1009    # region Recursive getters
1010    ###################################################################################
1011    ###################################################################################
1012
1013    @property
1014    def all_functions_called(self) -> List["Function"]:
1015        """
1016        list(Function): List of functions reachable from the contract
1017        Includes super, and private/internal functions not shadowed
1018        """
1019        from slither.slithir.operations import Operation
1020
1021        if self._all_functions_called is None:
1022            all_functions = [f for f in self.functions + self.modifiers if not f.is_shadowed]  # type: ignore
1023            all_callss = [f.all_internal_calls() for f in all_functions] + [list(all_functions)]
1024            all_calls = [
1025                item.function if isinstance(item, Operation) else item
1026                for sublist in all_callss
1027                for item in sublist
1028            ]
1029            all_calls = list(set(all_calls))
1030
1031            all_constructors = [c.constructor for c in self.inheritance if c.constructor]
1032            all_constructors = list(set(all_constructors))
1033
1034            set_all_calls = set(all_calls + list(all_constructors))
1035
1036            self._all_functions_called = [c for c in set_all_calls if isinstance(c, Function)]
1037        return self._all_functions_called
1038
1039    @property
1040    def all_state_variables_written(self) -> List["StateVariable"]:
1041        """
1042        list(StateVariable): List all of the state variables written
1043        """
1044        all_state_variables_writtens = [
1045            f.all_state_variables_written() for f in self.functions + self.modifiers  # type: ignore
1046        ]
1047        all_state_variables_written = [
1048            item for sublist in all_state_variables_writtens for item in sublist
1049        ]
1050        return list(set(all_state_variables_written))
1051
1052    @property
1053    def all_state_variables_read(self) -> List["StateVariable"]:
1054        """
1055        list(StateVariable): List all of the state variables read
1056        """
1057        all_state_variables_reads = [
1058            f.all_state_variables_read() for f in self.functions + self.modifiers  # type: ignore
1059        ]
1060        all_state_variables_read = [
1061            item for sublist in all_state_variables_reads for item in sublist
1062        ]
1063        return list(set(all_state_variables_read))
1064
1065    @property
1066    def all_library_calls(self) -> List["LibraryCall"]:
1067        """
1068        list(LibraryCall): List all of the libraries func called
1069        """
1070        all_high_level_callss = [f.all_library_calls() for f in self.functions + self.modifiers]  # type: ignore
1071        all_high_level_calls = [item for sublist in all_high_level_callss for item in sublist]
1072        return list(set(all_high_level_calls))
1073
1074    @property
1075    def all_high_level_calls(self) -> List[Tuple["Contract", "HighLevelCall"]]:
1076        """
1077        list(Tuple("Contract", "HighLevelCall")): List all of the external high level calls
1078        """
1079        all_high_level_callss = [f.all_high_level_calls() for f in self.functions + self.modifiers]  # type: ignore
1080        all_high_level_calls = [item for sublist in all_high_level_callss for item in sublist]
1081        return list(set(all_high_level_calls))
1082
1083    # endregion
1084    ###################################################################################
1085    ###################################################################################
1086    # region Summary information
1087    ###################################################################################
1088    ###################################################################################
1089
1090    def get_summary(
1091        self, include_shadowed: bool = True
1092    ) -> Tuple[str, List[str], List[str], List, List]:
1093        """Return the function summary
1094
1095        :param include_shadowed: boolean to indicate if shadowed functions should be included (default True)
1096        Returns:
1097            (str, list, list, list, list): (name, inheritance, variables, fuction summaries, modifier summaries)
1098        """
1099        func_summaries = [
1100            f.get_summary() for f in self.functions if (not f.is_shadowed or include_shadowed)
1101        ]
1102        modif_summaries = [
1103            f.get_summary() for f in self.modifiers if (not f.is_shadowed or include_shadowed)
1104        ]
1105        return (
1106            self.name,
1107            [str(x) for x in self.inheritance],
1108            [str(x) for x in self.variables],
1109            func_summaries,
1110            modif_summaries,
1111        )
1112
1113    def is_signature_only(self) -> bool:
1114        """Detect if the contract has only abstract functions
1115
1116        Returns:
1117            bool: true if the function are abstract functions
1118        """
1119        return all((not f.is_implemented) for f in self.functions)
1120
1121    # endregion
1122    ###################################################################################
1123    ###################################################################################
1124    # region ERC conformance
1125    ###################################################################################
1126    ###################################################################################
1127
1128    def ercs(self) -> List[str]:
1129        """
1130        Return the ERC implemented
1131        :return: list of string
1132        """
1133        all_erc = [
1134            ("ERC20", self.is_erc20),
1135            ("ERC165", self.is_erc165),
1136            ("ERC1820", self.is_erc1820),
1137            ("ERC223", self.is_erc223),
1138            ("ERC721", self.is_erc721),
1139            ("ERC777", self.is_erc777),
1140            ("ERC2612", self.is_erc2612),
1141            ("ERC1363", self.is_erc1363),
1142            ("ERC4626", self.is_erc4626),
1143        ]
1144
1145        return [erc for erc, is_erc in all_erc if is_erc()]
1146
1147    def is_erc20(self) -> bool:
1148        """
1149            Check if the contract is an erc20 token
1150
1151            Note: it does not check for correct return values
1152        :return: Returns a true if the contract is an erc20
1153        """
1154        full_names = self.functions_signatures
1155        return all(s in full_names for s in ERC20_signatures)
1156
1157    def is_erc165(self) -> bool:
1158        """
1159            Check if the contract is an erc165 token
1160
1161            Note: it does not check for correct return values
1162        :return: Returns a true if the contract is an erc165
1163        """
1164        full_names = self.functions_signatures
1165        return all(s in full_names for s in ERC165_signatures)
1166
1167    def is_erc1820(self) -> bool:
1168        """
1169            Check if the contract is an erc1820
1170
1171            Note: it does not check for correct return values
1172        :return: Returns a true if the contract is an erc165
1173        """
1174        full_names = self.functions_signatures
1175        return all(s in full_names for s in ERC1820_signatures)
1176
1177    def is_erc223(self) -> bool:
1178        """
1179            Check if the contract is an erc223 token
1180
1181            Note: it does not check for correct return values
1182        :return: Returns a true if the contract is an erc223
1183        """
1184        full_names = self.functions_signatures
1185        return all(s in full_names for s in ERC223_signatures)
1186
1187    def is_erc721(self) -> bool:
1188        """
1189            Check if the contract is an erc721 token
1190
1191            Note: it does not check for correct return values
1192        :return: Returns a true if the contract is an erc721
1193        """
1194        full_names = self.functions_signatures
1195        return all(s in full_names for s in ERC721_signatures)
1196
1197    def is_erc777(self) -> bool:
1198        """
1199            Check if the contract is an erc777
1200
1201            Note: it does not check for correct return values
1202        :return: Returns a true if the contract is an erc165
1203        """
1204        full_names = self.functions_signatures
1205        return all(s in full_names for s in ERC777_signatures)
1206
1207    def is_erc1155(self) -> bool:
1208        """
1209            Check if the contract is an erc1155
1210
1211            Note: it does not check for correct return values
1212        :return: Returns a true if the contract is an erc1155
1213        """
1214        full_names = self.functions_signatures
1215        return all(s in full_names for s in ERC1155_signatures)
1216
1217    def is_erc4626(self) -> bool:
1218        """
1219            Check if the contract is an erc4626
1220
1221            Note: it does not check for correct return values
1222        :return: Returns a true if the contract is an erc4626
1223        """
1224        full_names = self.functions_signatures
1225        return all(s in full_names for s in ERC4626_signatures)
1226
1227    def is_erc2612(self) -> bool:
1228        """
1229            Check if the contract is an erc2612
1230
1231            Note: it does not check for correct return values
1232        :return: Returns a true if the contract is an erc2612
1233        """
1234        full_names = self.functions_signatures
1235        return all(s in full_names for s in ERC2612_signatures)
1236
1237    def is_erc1363(self) -> bool:
1238        """
1239            Check if the contract is an erc1363
1240
1241            Note: it does not check for correct return values
1242        :return: Returns a true if the contract is an erc1363
1243        """
1244        full_names = self.functions_signatures
1245        return all(s in full_names for s in ERC1363_signatures)
1246
1247    def is_erc4524(self) -> bool:
1248        """
1249            Check if the contract is an erc4524
1250
1251            Note: it does not check for correct return values
1252        :return: Returns a true if the contract is an erc4524
1253        """
1254        full_names = self.functions_signatures
1255        return all(s in full_names for s in ERC4524_signatures)
1256
1257    @property
1258    def is_token(self) -> bool:
1259        """
1260        Check if the contract follows one of the standard ERC token
1261        :return:
1262        """
1263        return (
1264            self.is_erc20()
1265            or self.is_erc721()
1266            or self.is_erc165()
1267            or self.is_erc223()
1268            or self.is_erc777()
1269            or self.is_erc1155()
1270        )
1271
1272    def is_possible_erc20(self) -> bool:
1273        """
1274        Checks if the provided contract could be attempting to implement ERC20 standards.
1275
1276        :return: Returns a boolean indicating if the provided contract met the token standard.
1277        """
1278        # We do not check for all the functions, as name(), symbol(), might give too many FPs
1279        full_names = self.functions_signatures
1280        return (
1281            "transfer(address,uint256)" in full_names
1282            or "transferFrom(address,address,uint256)" in full_names
1283            or "approve(address,uint256)" in full_names
1284        )
1285
1286    def is_possible_erc721(self) -> bool:
1287        """
1288        Checks if the provided contract could be attempting to implement ERC721 standards.
1289
1290        :return: Returns a boolean indicating if the provided contract met the token standard.
1291        """
1292        # We do not check for all the functions, as name(), symbol(), might give too many FPs
1293        full_names = self.functions_signatures
1294        return (
1295            "ownerOf(uint256)" in full_names
1296            or "safeTransferFrom(address,address,uint256,bytes)" in full_names
1297            or "safeTransferFrom(address,address,uint256)" in full_names
1298            or "setApprovalForAll(address,bool)" in full_names
1299            or "getApproved(uint256)" in full_names
1300            or "isApprovedForAll(address,address)" in full_names
1301        )
1302
1303    @property
1304    def is_possible_token(self) -> bool:
1305        """
1306        Check if the contract is a potential token (it might not implement all the functions)
1307        :return:
1308        """
1309        return self.is_possible_erc20() or self.is_possible_erc721()
1310
1311    # endregion
1312    ###################################################################################
1313    ###################################################################################
1314    # region Dependencies
1315    ###################################################################################
1316    ###################################################################################
1317
1318    def is_from_dependency(self) -> bool:
1319        return self.compilation_unit.core.crytic_compile.is_dependency(
1320            self.source_mapping.filename.absolute
1321        )
1322
1323    # endregion
1324    ###################################################################################
1325    ###################################################################################
1326    # region Test
1327    ###################################################################################
1328    ###################################################################################
1329
1330    @property
1331    def is_truffle_migration(self) -> bool:
1332        """
1333        Return true if the contract is the Migrations contract needed for Truffle
1334        :return:
1335        """
1336        if self.compilation_unit.core.crytic_compile.platform == PlatformType.TRUFFLE:
1337            if self.name == "Migrations":
1338                paths = Path(self.source_mapping.filename.absolute).parts
1339                if len(paths) >= 2:
1340                    return paths[-2] == "contracts" and paths[-1] == "migrations.sol"
1341        return False
1342
1343    @property
1344    def is_test(self) -> bool:
1345        return is_test_contract(self) or self.is_truffle_migration  # type: ignore
1346
1347    # endregion
1348    ###################################################################################
1349    ###################################################################################
1350    # region Function analyses
1351    ###################################################################################
1352    ###################################################################################
1353
1354    def update_read_write_using_ssa(self) -> None:
1355        for function in self.functions + list(self.modifiers):
1356            function.update_read_write_using_ssa()
1357
1358    # endregion
1359    ###################################################################################
1360    ###################################################################################
1361    # region Upgradeability
1362    ###################################################################################
1363    ###################################################################################
1364
1365    @property
1366    def is_upgradeable(self) -> bool:
1367        if self._is_upgradeable is None:
1368            self._is_upgradeable = False
1369            initializable = self.file_scope.get_contract_from_name("Initializable")
1370            if initializable:
1371                if initializable in self.inheritance:
1372                    self._is_upgradeable = True
1373            else:
1374                for contract in self.inheritance + [self]:
1375                    # This might lead to false positive
1376                    # Not sure why pylint is having a trouble here
1377                    # pylint: disable=no-member
1378                    lower_name = contract.name.lower()
1379                    if "upgradeable" in lower_name or "upgradable" in lower_name:
1380                        self._is_upgradeable = True
1381                        break
1382                    if "initializable" in lower_name:
1383                        self._is_upgradeable = True
1384                        break
1385        return self._is_upgradeable
1386
1387    @is_upgradeable.setter
1388    def is_upgradeable(self, upgradeable: bool) -> None:
1389        self._is_upgradeable = upgradeable
1390
1391    @property
1392    def is_upgradeable_proxy(self) -> bool:
1393        from slither.core.cfg.node import NodeType
1394        from slither.slithir.operations import LowLevelCall
1395
1396        if self._is_upgradeable_proxy is None:
1397            self._is_upgradeable_proxy = False
1398            if "Proxy" in self.name:
1399                self._is_upgradeable_proxy = True
1400                return True
1401            for f in self.functions:
1402                if f.is_fallback:
1403                    for node in f.all_nodes():
1404                        for ir in node.irs:
1405                            if isinstance(ir, LowLevelCall) and ir.function_name == "delegatecall":
1406                                self._is_upgradeable_proxy = True
1407                                return self._is_upgradeable_proxy
1408                        if node.type == NodeType.ASSEMBLY:
1409                            inline_asm = node.inline_asm
1410                            if inline_asm:
1411                                if "delegatecall" in inline_asm:
1412                                    self._is_upgradeable_proxy = True
1413                                    return self._is_upgradeable_proxy
1414        return self._is_upgradeable_proxy
1415
1416    @is_upgradeable_proxy.setter
1417    def is_upgradeable_proxy(self, upgradeable_proxy: bool) -> None:
1418        self._is_upgradeable_proxy = upgradeable_proxy
1419
1420    @property
1421    def upgradeable_version(self) -> Optional[str]:
1422        return self._upgradeable_version
1423
1424    @upgradeable_version.setter
1425    def upgradeable_version(self, version_name: str) -> None:
1426        self._upgradeable_version = version_name
1427
1428    # endregion
1429    ###################################################################################
1430    ###################################################################################
1431    # region Internals
1432    ###################################################################################
1433    ###################################################################################
1434
1435    @property
1436    def is_incorrectly_constructed(self) -> bool:
1437        """
1438        Return true if there was an internal Slither's issue when analyzing the contract
1439        :return:
1440        """
1441        return self._is_incorrectly_parsed
1442
1443    @is_incorrectly_constructed.setter
1444    def is_incorrectly_constructed(self, incorrect: bool) -> None:
1445        self._is_incorrectly_parsed = incorrect
1446
1447    def add_constructor_variables(self) -> None:
1448        from slither.core.declarations.function_contract import FunctionContract
1449
1450        if self.state_variables:
1451            for (idx, variable_candidate) in enumerate(self.state_variables):
1452                if variable_candidate.expression and not variable_candidate.is_constant:
1453
1454                    constructor_variable = FunctionContract(self.compilation_unit)
1455                    constructor_variable.set_function_type(FunctionType.CONSTRUCTOR_VARIABLES)
1456                    constructor_variable.set_contract(self)  # type: ignore
1457                    constructor_variable.set_contract_declarer(self)  # type: ignore
1458                    constructor_variable.set_visibility("internal")
1459                    # For now, source mapping of the constructor variable is the whole contract
1460                    # Could be improved with a targeted source mapping
1461                    constructor_variable.set_offset(self.source_mapping, self.compilation_unit)
1462                    self._functions[constructor_variable.canonical_name] = constructor_variable
1463
1464                    prev_node = self._create_node(
1465                        constructor_variable, 0, variable_candidate, constructor_variable
1466                    )
1467                    variable_candidate.node_initialization = prev_node
1468                    counter = 1
1469                    for v in self.state_variables[idx + 1 :]:
1470                        if v.expression and not v.is_constant:
1471                            next_node = self._create_node(
1472                                constructor_variable, counter, v, prev_node.scope
1473                            )
1474                            v.node_initialization = next_node
1475                            prev_node.add_son(next_node)
1476                            next_node.add_father(prev_node)
1477                            prev_node = next_node
1478                            counter += 1
1479                    break
1480
1481            for (idx, variable_candidate) in enumerate(self.state_variables):
1482                if variable_candidate.expression and variable_candidate.is_constant:
1483
1484                    constructor_variable = FunctionContract(self.compilation_unit)
1485                    constructor_variable.set_function_type(
1486                        FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES
1487                    )
1488                    constructor_variable.set_contract(self)  # type: ignore
1489                    constructor_variable.set_contract_declarer(self)  # type: ignore
1490                    constructor_variable.set_visibility("internal")
1491                    # For now, source mapping of the constructor variable is the whole contract
1492                    # Could be improved with a targeted source mapping
1493                    constructor_variable.set_offset(self.source_mapping, self.compilation_unit)
1494                    self._functions[constructor_variable.canonical_name] = constructor_variable
1495
1496                    prev_node = self._create_node(
1497                        constructor_variable, 0, variable_candidate, constructor_variable
1498                    )
1499                    variable_candidate.node_initialization = prev_node
1500                    counter = 1
1501                    for v in self.state_variables[idx + 1 :]:
1502                        if v.expression and v.is_constant:
1503                            next_node = self._create_node(
1504                                constructor_variable, counter, v, prev_node.scope
1505                            )
1506                            v.node_initialization = next_node
1507                            prev_node.add_son(next_node)
1508                            next_node.add_father(prev_node)
1509                            prev_node = next_node
1510                            counter += 1
1511
1512                    break
1513
1514    def _create_node(
1515        self, func: Function, counter: int, variable: "Variable", scope: Union[Scope, Function]
1516    ) -> "Node":
1517        from slither.core.cfg.node import Node, NodeType
1518        from slither.core.expressions import (
1519            AssignmentOperationType,
1520            AssignmentOperation,
1521            Identifier,
1522        )
1523
1524        # Function uses to create node for state variable declaration statements
1525        node = Node(NodeType.OTHER_ENTRYPOINT, counter, scope, func.file_scope)
1526        node.set_offset(variable.source_mapping, self.compilation_unit)
1527        node.set_function(func)
1528        func.add_node(node)
1529        assert variable.expression
1530        expression = AssignmentOperation(
1531            Identifier(variable),
1532            variable.expression,
1533            AssignmentOperationType.ASSIGN,
1534            variable.type,
1535        )
1536
1537        expression.set_offset(variable.source_mapping, self.compilation_unit)
1538        node.add_expression(expression)
1539        return node
1540
1541    # endregion
1542    ###################################################################################
1543    ###################################################################################
1544    # region SlithIR
1545    ###################################################################################
1546    ###################################################################################
1547
1548    def convert_expression_to_slithir_ssa(self) -> None:
1549        """
1550        Assume generate_slithir_and_analyze was called on all functions
1551
1552        :return:
1553        """
1554        from slither.slithir.variables import StateIRVariable
1555
1556        all_ssa_state_variables_instances = {}
1557
1558        for contract in self.inheritance:
1559            for v in contract.state_variables_declared:
1560                new_var = StateIRVariable(v)
1561                all_ssa_state_variables_instances[v.canonical_name] = new_var
1562                self._initial_state_variables.append(new_var)
1563
1564        for v in self.variables:
1565            if v.contract == self:
1566                new_var = StateIRVariable(v)
1567                all_ssa_state_variables_instances[v.canonical_name] = new_var
1568                self._initial_state_variables.append(new_var)
1569
1570        for func in self.functions + list(self.modifiers):
1571            func.generate_slithir_ssa(all_ssa_state_variables_instances)
1572
1573    def fix_phi(self) -> None:
1574        last_state_variables_instances: Dict[str, List["StateVariable"]] = {}
1575        initial_state_variables_instances: Dict[str, "StateVariable"] = {}
1576        for v in self._initial_state_variables:
1577            last_state_variables_instances[v.canonical_name] = []
1578            initial_state_variables_instances[v.canonical_name] = v
1579
1580        for func in self.functions + list(self.modifiers):
1581            result = func.get_last_ssa_state_variables_instances()
1582            for variable_name, instances in result.items():
1583                # TODO: investigate the next operation
1584                last_state_variables_instances[variable_name] += list(instances)
1585
1586        for func in self.functions + list(self.modifiers):
1587            func.fix_phi(last_state_variables_instances, initial_state_variables_instances)
1588
1589    # endregion
1590    ###################################################################################
1591    ###################################################################################
1592    # region Built in definitions
1593    ###################################################################################
1594    ###################################################################################
1595
1596    def __eq__(self, other: Any) -> bool:
1597        if isinstance(other, str):
1598            return other == self.name
1599        return NotImplemented
1600
1601    def __neq__(self, other: Any) -> bool:
1602        if isinstance(other, str):
1603            return other != self.name
1604        return NotImplemented
1605
1606    def __str__(self) -> str:
1607        return self.name
1608
1609    def __hash__(self) -> int:
1610        return self._id  # type:ignore
1611
1612    # endregion