slither.core.declarations.contract

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