CINXE.COM

<!DOCTYPE html> <html class="writer-html5" lang="en"> <head> <meta charset="utf-8" /><meta name="generator" content="Docutils 0.19: https://docutils.sourceforge.io/" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Contracts — Solidity 0.8.29 documentation</title> <link rel="stylesheet" type="text/css" href="_static/pygments.css" /> <link rel="stylesheet" type="text/css" href="_static/css/theme.css" /> <link rel="stylesheet" type="text/css" href="_static/a4_railroad_diagram.css" /> <link rel="stylesheet" type="text/css" href="_static/css/fonts.css" /> <link rel="stylesheet" type="text/css" href="_static/css/custom.css" /> <link rel="stylesheet" type="text/css" href="_static/css/custom-dark.css" /> <link rel="stylesheet" type="text/css" href="_static/css/pygments.css" /> <link rel="stylesheet" type="text/css" href="_static/css/toggle.css" /> <link rel="shortcut icon" href="_static/favicon.ico"/>  <script data-url_root="./" id="documentation_options" src="_static/documentation_options.js"></script> <script src="_static/jquery.js"></script> <script src="_static/underscore.js"></script> <script src="_static/_sphinx_javascript_frameworks_compat.js"></script> <script src="_static/doctools.js"></script> <script src="_static/sphinx_highlight.js"></script> <script src="_static/js/constants.js"></script> <script src="_static/js/initialize.js"></script> <script src="_static/js/toggle.js"></script> <script src="_static/js/theme.js"></script> <link rel="index" title="Index" href="genindex.html" /> <link rel="search" title="Search" href="search.html" /> <link rel="next" title="Inline Assembly" href="assembly.html" /> <link rel="prev" title="Expressions and Control Structures" href="control-structures.html" /> <script async type="text/javascript" src="/_/static/javascript/readthedocs-addons.js"></script><meta name="readthedocs-project-slug" content="solidity" /><meta name="readthedocs-version-slug" content="latest" /><meta name="readthedocs-resolver-filename" content="/contracts.html" /><meta name="readthedocs-http-status" content="200" /></head> <body class="wy-body-for-nav"> <div class="wy-grid-for-nav"> <nav data-toggle="wy-nav-shift" class="wy-nav-side"> <div class="wy-side-scroll"> <div class="wy-side-nav-search" > <a href="index.html"> </a> <div class="version"> 0.8.29 </div> <div role="search"> <form id="rtd-search-form" class="wy-form" action="search.html" method="get"> <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" /> <input type="hidden" name="check_keywords" value="yes" /> <input type="hidden" name="area" value="default" /> </form> </div> </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu"> Basics <ul> <li class="toctree-l1"><a class="reference internal" href="introduction-to-smart-contracts.html">Introduction to Smart Contracts</a></li> <li class="toctree-l1"><a class="reference internal" href="solidity-by-example.html">Solidity by Example</a></li> <li class="toctree-l1"><a class="reference internal" href="installing-solidity.html">Installing the Solidity Compiler</a></li> </ul> Language Description <ul class="current"> <li class="toctree-l1"><a class="reference internal" href="layout-of-source-files.html">Layout of a Solidity Source File</a></li> <li class="toctree-l1"><a class="reference internal" href="structure-of-a-contract.html">Structure of a Contract</a></li> <li class="toctree-l1"><a class="reference internal" href="types.html">Types</a></li> <li class="toctree-l1"><a class="reference internal" href="units-and-global-variables.html">Units and Globally Available Variables</a></li> <li class="toctree-l1"><a class="reference internal" href="control-structures.html">Expressions and Control Structures</a></li> <li class="toctree-l1 current"><a class="current reference internal" href="#">Contracts</a><ul> <li class="toctree-l2"><a class="reference internal" href="#creating-contracts">Creating Contracts</a></li> <li class="toctree-l2"><a class="reference internal" href="#visibility-and-getters">Visibility and Getters</a><ul> <li class="toctree-l3"><a class="reference internal" href="#state-variable-visibility">State Variable Visibility</a></li> <li class="toctree-l3"><a class="reference internal" href="#function-visibility">Function Visibility</a></li> <li class="toctree-l3"><a class="reference internal" href="#getter-functions">Getter Functions</a></li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#function-modifiers">Function Modifiers</a></li> <li class="toctree-l2"><a class="reference internal" href="#transient-storage">Transient Storage</a></li> <li class="toctree-l2"><a class="reference internal" href="#composability-of-smart-contracts-and-the-caveats-of-transient-storage">Composability of Smart Contracts and the Caveats of Transient Storage</a></li> <li class="toctree-l2"><a class="reference internal" href="#constant-and-immutable-state-variables">Constant and Immutable State Variables</a><ul> <li class="toctree-l3"><a class="reference internal" href="#constant">Constant</a></li> <li class="toctree-l3"><a class="reference internal" href="#immutable">Immutable</a></li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#functions">Functions</a><ul> <li class="toctree-l3"><a class="reference internal" href="#function-parameters-and-return-variables">Function Parameters and Return Variables</a><ul> <li class="toctree-l4"><a class="reference internal" href="#function-parameters">Function Parameters</a></li> <li class="toctree-l4"><a class="reference internal" href="#return-variables">Return Variables</a></li> <li class="toctree-l4"><a class="reference internal" href="#returning-multiple-values">Returning Multiple Values</a></li> </ul> </li> <li class="toctree-l3"><a class="reference internal" href="#state-mutability">State Mutability</a><ul> <li class="toctree-l4"><a class="reference internal" href="#view-functions">View Functions</a></li> <li class="toctree-l4"><a class="reference internal" href="#pure-functions">Pure Functions</a></li> </ul> </li> <li class="toctree-l3"><a class="reference internal" href="#special-functions">Special Functions</a><ul> <li class="toctree-l4"><a class="reference internal" href="#receive-ether-function">Receive Ether Function</a></li> <li class="toctree-l4"><a class="reference internal" href="#fallback-function">Fallback Function</a></li> </ul> </li> <li class="toctree-l3"><a class="reference internal" href="#function-overloading">Function Overloading</a><ul> <li class="toctree-l4"><a class="reference internal" href="#overload-resolution-and-argument-matching">Overload resolution and Argument matching</a></li> </ul> </li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#events">Events</a><ul> <li class="toctree-l3"><a class="reference internal" href="#members-of-events">Members of Events</a></li> <li class="toctree-l3"><a class="reference internal" href="#example">Example</a></li> <li class="toctree-l3"><a class="reference internal" href="#additional-resources-for-understanding-events">Additional Resources for Understanding Events</a></li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#custom-errors">Custom Errors</a><ul> <li class="toctree-l3"><a class="reference internal" href="#members-of-errors">Members of Errors</a></li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#inheritance">Inheritance</a><ul> <li class="toctree-l3"><a class="reference internal" href="#function-overriding">Function Overriding</a></li> <li class="toctree-l3"><a class="reference internal" href="#modifier-overriding">Modifier Overriding</a></li> <li class="toctree-l3"><a class="reference internal" href="#constructors">Constructors</a></li> <li class="toctree-l3"><a class="reference internal" href="#arguments-for-base-constructors">Arguments for Base Constructors</a></li> <li class="toctree-l3"><a class="reference internal" href="#multiple-inheritance-and-linearization">Multiple Inheritance and Linearization</a></li> <li class="toctree-l3"><a class="reference internal" href="#inheriting-different-kinds-of-members-of-the-same-name">Inheriting Different Kinds of Members of the Same Name</a></li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#abstract-contracts">Abstract Contracts</a></li> <li class="toctree-l2"><a class="reference internal" href="#interfaces">Interfaces</a></li> <li class="toctree-l2"><a class="reference internal" href="#libraries">Libraries</a><ul> <li class="toctree-l3"><a class="reference internal" href="#function-signatures-and-selectors-in-libraries">Function Signatures and Selectors in Libraries</a></li> <li class="toctree-l3"><a class="reference internal" href="#call-protection-for-libraries">Call Protection For Libraries</a></li> </ul> </li> <li class="toctree-l2"><a class="reference internal" href="#using-for">Using For</a></li> </ul> </li> <li class="toctree-l1"><a class="reference internal" href="assembly.html">Inline Assembly</a></li> <li class="toctree-l1"><a class="reference internal" href="cheatsheet.html">Cheatsheet</a></li> <li class="toctree-l1"><a class="reference internal" href="grammar.html">Language Grammar</a></li> </ul> Compiler <ul> <li class="toctree-l1"><a class="reference internal" href="using-the-compiler.html">Using the Compiler</a></li> <li class="toctree-l1"><a class="reference internal" href="analysing-compilation-output.html">Analysing the Compiler Output</a></li> <li class="toctree-l1"><a class="reference internal" href="ir-breaking-changes.html">Solidity IR-based Codegen Changes</a></li> </ul> Internals <ul> <li class="toctree-l1"><a class="reference internal" href="internals/layout_in_storage.html">Layout of State Variables in Storage and Transient Storage</a></li> <li class="toctree-l1"><a class="reference internal" href="internals/layout_in_memory.html">Layout in Memory</a></li> <li class="toctree-l1"><a class="reference internal" href="internals/layout_in_calldata.html">Layout of Call Data</a></li> <li class="toctree-l1"><a class="reference internal" href="internals/variable_cleanup.html">Cleaning Up Variables</a></li> <li class="toctree-l1"><a class="reference internal" href="internals/source_mappings.html">Source Mappings</a></li> <li class="toctree-l1"><a class="reference internal" href="internals/optimizer.html">The Optimizer</a></li> <li class="toctree-l1"><a class="reference internal" href="metadata.html">Contract Metadata</a></li> <li class="toctree-l1"><a class="reference internal" href="abi-spec.html">Contract ABI Specification</a></li> </ul> Advisory content <ul> <li class="toctree-l1"><a class="reference internal" href="security-considerations.html">Security Considerations</a></li> <li class="toctree-l1"><a class="reference internal" href="bugs.html">List of Known Bugs</a></li> <li class="toctree-l1"><a class="reference internal" href="050-breaking-changes.html">Solidity v0.5.0 Breaking Changes</a></li> <li class="toctree-l1"><a class="reference internal" href="060-breaking-changes.html">Solidity v0.6.0 Breaking Changes</a></li> <li class="toctree-l1"><a class="reference internal" href="070-breaking-changes.html">Solidity v0.7.0 Breaking Changes</a></li> <li class="toctree-l1"><a class="reference internal" href="080-breaking-changes.html">Solidity v0.8.0 Breaking Changes</a></li> </ul> Additional Material <ul> <li class="toctree-l1"><a class="reference internal" href="natspec-format.html">NatSpec Format</a></li> <li class="toctree-l1"><a class="reference internal" href="smtchecker.html">SMTChecker and Formal Verification</a></li> <li class="toctree-l1"><a class="reference internal" href="yul.html">Yul</a></li> <li class="toctree-l1"><a class="reference internal" href="path-resolution.html">Import Path Resolution</a></li> </ul> Resources <ul> <li class="toctree-l1"><a class="reference internal" href="style-guide.html">Style Guide</a></li> <li class="toctree-l1"><a class="reference internal" href="common-patterns.html">Common Patterns</a></li> <li class="toctree-l1"><a class="reference internal" href="resources.html">Resources</a></li> <li class="toctree-l1"><a class="reference internal" href="contributing.html">Contributing</a></li> <li class="toctree-l1"><a class="reference internal" href="language-influences.html">Language Influences</a></li> <li class="toctree-l1"><a class="reference internal" href="brand-guide.html">Solidity Brand Guide</a></li> </ul> <ul> <li> <a href="genindex.html">Keyword Index</a> </li> </ul> </div> </div> </nav> <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" > <a href="index.html">Solidity</a> </nav> <div class="wy-nav-content"> <div class="rst-content"> <div role="navigation" aria-label="Page navigation"> <ul class="wy-breadcrumbs"> <li><a href="index.html" class="icon icon-home" aria-label="Home"></a></li> <li class="breadcrumb-item active">Contracts</li> <li class="wy-breadcrumbs-aside"> <a href="https://github.com/ethereum/solidity/blob/latest/docs/contracts.rst" class="fa fa-github"> Edit on GitHub</a> </li> </ul> <hr/> </div> <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article"> <div itemprop="articleBody"> <section id="contracts"> <h1>Contracts<a class="headerlink" href="#contracts" title="Permalink to this heading"></a></h1> Contracts in Solidity are similar to classes in object-oriented languages. They contain persistent data in state variables, and functions that can modify these variables. Calling a function on a different contract (instance) will perform an EVM function call and thus switch the context such that state variables in the calling contract are inaccessible. A contract and its functions need to be called for anything to happen. There is no “cron” concept in Ethereum to call a function at a particular event automatically. <section id="creating-contracts"> <h2>Creating Contracts<a class="headerlink" href="#creating-contracts" title="Permalink to this heading"></a></h2> Contracts can be created “from outside” via Ethereum transactions or from within Solidity contracts. IDEs, such as <a class="reference external" href="https://remix.ethereum.org/">Remix</a>, make the creation process seamless using UI elements. One way to create contracts programmatically on Ethereum is via the JavaScript API <a class="reference external" href="https://github.com/web3/web3.js">web3.js</a>. It has a function called <a class="reference external" href="https://web3js.readthedocs.io/en/1.0/web3-eth-contract.html#new-contract">web3.eth.Contract</a> to facilitate contract creation. When a contract is created, its <a class="reference internal" href="#constructor">constructor</a> (a function declared with the <code class="docutils literal notranslate">constructor</code> keyword) is executed once. A constructor is optional. Only one constructor is allowed, which means overloading is not supported. After the constructor has executed, the final code of the contract is stored on the blockchain. This code includes all public and external functions and all functions that are reachable from there through function calls. The deployed code does not include the constructor code or internal functions only called from the constructor. Internally, constructor arguments are passed <a class="reference internal" href="abi-spec.html#abi">ABI encoded</a> after the code of the contract itself, but you do not have to care about this if you use <code class="docutils literal notranslate">web3.js</code>. If a contract wants to create another contract, the source code (and the binary) of the created contract has to be known to the creator. This means that cyclic creation dependencies are impossible. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=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" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.22 <0.9.0; contract OwnedToken { // `TokenCreator` is a contract type that is defined below. // It is fine to reference it as long as it is not used // to create a new contract. TokenCreator creator; address owner; bytes32 name; // This is the constructor which registers the // creator and the assigned name. constructor(bytes32 name_) { // State variables are accessed via their name // and not via e.g. `this.owner`. Functions can // be accessed directly or through `this.f`, // but the latter provides an external view // to the function. Especially in the constructor, // you should not access functions externally, // because the function does not exist yet. // See the next section for details. owner = msg.sender; // We perform an explicit type conversion from `address` // to `TokenCreator` and assume that the type of // the calling contract is `TokenCreator`, there is // no real way to verify that. // This does not create a new contract. creator = TokenCreator(msg.sender); name = name_; } function changeName(bytes32 newName) public { // Only the creator can alter the name. // We compare the contract based on its // address which can be retrieved by // explicit conversion to address. if (msg.sender == address(creator)) name = newName; } function transfer(address newOwner) public { // Only the current owner can transfer the token. if (msg.sender != owner) return; // We ask the creator contract if the transfer // should proceed by using a function of the // `TokenCreator` contract defined below. If // the call fails (e.g. due to out-of-gas), // the execution also fails here. if (creator.isTokenTransferOK(owner, newOwner)) owner = newOwner; } } contract TokenCreator { function createToken(bytes32 name) public returns (OwnedToken tokenAddress) { // Create a new `Token` contract and return its address. // From the JavaScript side, the return type // of this function is `address`, as this is // the closest type available in the ABI. return new OwnedToken(name); } function changeName(OwnedToken tokenAddress, bytes32 name) public { // Again, the external type of `tokenAddress` is // simply `address`. tokenAddress.changeName(name); } // Perform checks to determine if transferring a token to the // `OwnedToken` contract should proceed function isTokenTransferOK(address currentOwner, address newOwner) public pure returns (bool ok) { // Check an arbitrary condition to see if transfer should proceed return keccak256(abi.encodePacked(currentOwner, newOwner))[0] == 0x7f; } } </pre></div> </div> </section> <section id="visibility-and-getters"> <h2>Visibility and Getters<a class="headerlink" href="#visibility-and-getters" title="Permalink to this heading"></a></h2> <section id="state-variable-visibility"> <h3>State Variable Visibility<a class="headerlink" href="#state-variable-visibility" title="Permalink to this heading"></a></h3> <dl class="simple"> <dt><code class="docutils literal notranslate">public</code></dt><dd>Public state variables differ from internal ones only in that the compiler automatically generates <a class="reference internal" href="#getter-functions">getter functions</a> for them, which allows other contracts to read their values. When used within the same contract, the external access (e.g. <code class="docutils literal notranslate">this.x</code>) invokes the getter while internal access (e.g. <code class="docutils literal notranslate">x</code>) gets the variable value directly from storage. Setter functions are not generated so other contracts cannot directly modify their values. </dd> <dt><code class="docutils literal notranslate">internal</code></dt><dd>Internal state variables can only be accessed from within the contract they are defined in and in derived contracts. They cannot be accessed externally. This is the default visibility level for state variables. </dd> <dt><code class="docutils literal notranslate">private</code></dt><dd>Private state variables are like internal ones but they are not visible in derived contracts. </dd> </dl> <div class="admonition warning"> Warning Making something <code class="docutils literal notranslate">private</code> or <code class="docutils literal notranslate">internal</code> only prevents other contracts from reading or modifying the information, but it will still be visible to the whole world outside of the blockchain. </div> </section> <section id="function-visibility"> <h3>Function Visibility<a class="headerlink" href="#function-visibility" title="Permalink to this heading"></a></h3> Solidity knows two kinds of function calls: external ones that do create an actual EVM message call and internal ones that do not. Furthermore, internal functions can be made inaccessible to derived contracts. This gives rise to four types of visibility for functions. <dl class="simple"> <dt><code class="docutils literal notranslate">external</code></dt><dd>External functions are part of the contract interface, which means they can be called from other contracts and via transactions. An external function <code class="docutils literal notranslate">f</code> cannot be called internally (i.e. <code class="docutils literal notranslate">f()</code> does not work, but <code class="docutils literal notranslate">this.f()</code> works). </dd> <dt><code class="docutils literal notranslate">public</code></dt><dd>Public functions are part of the contract interface and can be either called internally or via message calls. </dd> <dt><code class="docutils literal notranslate">internal</code></dt><dd>Internal functions can only be accessed from within the current contract or contracts deriving from it. They cannot be accessed externally. Since they are not exposed to the outside through the contract’s ABI, they can take parameters of internal types like mappings or storage references. </dd> <dt><code class="docutils literal notranslate">private</code></dt><dd>Private functions are like internal ones but they are not visible in derived contracts. </dd> </dl> <div class="admonition warning"> Warning Making something <code class="docutils literal notranslate">private</code> or <code class="docutils literal notranslate">internal</code> only prevents other contracts from reading or modifying the information, but it will still be visible to the whole world outside of the blockchain. </div> The visibility specifier is given after the type for state variables and between parameter list and return parameter list for functions. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IEMgewogICAgZnVuY3Rpb24gZih1aW50IGEpIHByaXZhdGUgcHVyZSByZXR1cm5zICh1aW50IGIpIHsgcmV0dXJuIGEgKyAxOyB9CiAgICBmdW5jdGlvbiBzZXREYXRhKHVpbnQgYSkgaW50ZXJuYWwgeyBkYXRhID0gYTsgfQogICAgdWludCBwdWJsaWMgZGF0YTsKfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract C { function f(uint a) private pure returns (uint b) { return a + 1; } function setData(uint a) internal { data = a; } uint public data; } </pre></div> </div> In the following example, <code class="docutils literal notranslate">D</code>, can call <code class="docutils literal notranslate">c.getData()</code> to retrieve the value of <code class="docutils literal notranslate">data</code> in state storage, but is not able to call <code class="docutils literal notranslate">f</code>. Contract <code class="docutils literal notranslate">E</code> is derived from <code class="docutils literal notranslate">C</code> and, thus, can call <code class="docutils literal notranslate">compute</code>. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IEMgewogICAgdWludCBwcml2YXRlIGRhdGE7CgogICAgZnVuY3Rpb24gZih1aW50IGEpIHByaXZhdGUgcHVyZSByZXR1cm5zKHVpbnQgYikgeyByZXR1cm4gYSArIDE7IH0KICAgIGZ1bmN0aW9uIHNldERhdGEodWludCBhKSBwdWJsaWMgeyBkYXRhID0gYTsgfQogICAgZnVuY3Rpb24gZ2V0RGF0YSgpIHB1YmxpYyB2aWV3IHJldHVybnModWludCkgeyByZXR1cm4gZGF0YTsgfQogICAgZnVuY3Rpb24gY29tcHV0ZSh1aW50IGEsIHVpbnQgYikgaW50ZXJuYWwgcHVyZSByZXR1cm5zICh1aW50KSB7IHJldHVybiBhICsgYjsgfQp9CgovLyBUaGlzIHdpbGwgbm90IGNvbXBpbGUKY29udHJhY3QgRCB7CiAgICBmdW5jdGlvbiByZWFkRGF0YSgpIHB1YmxpYyB7CiAgICAgICAgQyBjID0gbmV3IEMoKTsKICAgICAgICB1aW50IGxvY2FsID0gYy5mKDcpOyAvLyBlcnJvcjogbWVtYmVyIGBmYCBpcyBub3QgdmlzaWJsZQogICAgICAgIGMuc2V0RGF0YSgzKTsKICAgICAgICBsb2NhbCA9IGMuZ2V0RGF0YSgpOwogICAgICAgIGxvY2FsID0gYy5jb21wdXRlKDMsIDUpOyAvLyBlcnJvcjogbWVtYmVyIGBjb21wdXRlYCBpcyBub3QgdmlzaWJsZQogICAgfQp9Cgpjb250cmFjdCBFIGlzIEMgewogICAgZnVuY3Rpb24gZygpIHB1YmxpYyB7CiAgICAgICAgQyBjID0gbmV3IEMoKTsKICAgICAgICB1aW50IHZhbCA9IGNvbXB1dGUoMywgNSk7IC8vIGFjY2VzcyB0byBpbnRlcm5hbCBtZW1iZXIgKGZyb20gZGVyaXZlZCB0byBwYXJlbnQgY29udHJhY3QpCiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract C { uint private data; function f(uint a) private pure returns(uint b) { return a + 1; } function setData(uint a) public { data = a; } function getData() public view returns(uint) { return data; } function compute(uint a, uint b) internal pure returns (uint) { return a + b; } } // This will not compile contract D { function readData() public { C c = new C(); uint local = c.f(7); // error: member `f` is not visible c.setData(3); local = c.getData(); local = c.compute(3, 5); // error: member `compute` is not visible } } contract E is C { function g() public { C c = new C(); uint val = compute(3, 5); // access to internal member (from derived to parent contract) } } </pre></div> </div> </section> <section id="getter-functions"> <h3>Getter Functions<a class="headerlink" href="#getter-functions" title="Permalink to this heading"></a></h3> The compiler automatically creates getter functions for all public state variables. For the contract given below, the compiler will generate a function called <code class="docutils literal notranslate">data</code> that does not take any arguments and returns a <code class="docutils literal notranslate">uint</code>, the value of the state variable <code class="docutils literal notranslate">data</code>. State variables can be initialized when they are declared. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IEMgewogICAgdWludCBwdWJsaWMgZGF0YSA9IDQyOwp9Cgpjb250cmFjdCBDYWxsZXIgewogICAgQyBjID0gbmV3IEMoKTsKICAgIGZ1bmN0aW9uIGYoKSBwdWJsaWMgdmlldyByZXR1cm5zICh1aW50KSB7CiAgICAgICAgcmV0dXJuIGMuZGF0YSgpOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract C { uint public data = 42; } contract Caller { C c = new C(); function f() public view returns (uint) { return c.data(); } } </pre></div> </div> The getter functions have external visibility. If the symbol is accessed internally (i.e. without <code class="docutils literal notranslate">this.</code>), it evaluates to a state variable. If it is accessed externally (i.e. with <code class="docutils literal notranslate">this.</code>), it evaluates to a function. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjAgPDAuOS4wOwoKY29udHJhY3QgQyB7CiAgICB1aW50IHB1YmxpYyBkYXRhOwogICAgZnVuY3Rpb24geCgpIHB1YmxpYyByZXR1cm5zICh1aW50KSB7CiAgICAgICAgZGF0YSA9IDM7IC8vIGludGVybmFsIGFjY2VzcwogICAgICAgIHJldHVybiB0aGlzLmRhdGEoKTsgLy8gZXh0ZXJuYWwgYWNjZXNzCiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.0 <0.9.0; contract C { uint public data; function x() public returns (uint) { data = 3; // internal access return this.data(); // external access } } </pre></div> </div> If you have a <code class="docutils literal notranslate">public</code> state variable of array type, then you can only retrieve single elements of the array via the generated getter function. This mechanism exists to avoid high gas costs when returning an entire array. You can use arguments to specify which individual element to return, for example <code class="docutils literal notranslate">myArray(0)</code>. If you want to return an entire array in one call, then you need to write a function, for example: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IGFycmF5RXhhbXBsZSB7CiAgICAvLyBwdWJsaWMgc3RhdGUgdmFyaWFibGUKICAgIHVpbnRbXSBwdWJsaWMgbXlBcnJheTsKCiAgICAvLyBHZXR0ZXIgZnVuY3Rpb24gZ2VuZXJhdGVkIGJ5IHRoZSBjb21waWxlcgogICAgLyoKICAgIGZ1bmN0aW9uIG15QXJyYXkodWludCBpKSBwdWJsaWMgdmlldyByZXR1cm5zICh1aW50KSB7CiAgICAgICAgcmV0dXJuIG15QXJyYXlbaV07CiAgICB9CiAgICAqLwoKICAgIC8vIGZ1bmN0aW9uIHRoYXQgcmV0dXJucyBlbnRpcmUgYXJyYXkKICAgIGZ1bmN0aW9uIGdldEFycmF5KCkgcHVibGljIHZpZXcgcmV0dXJucyAodWludFtdIG1lbW9yeSkgewogICAgICAgIHJldHVybiBteUFycmF5OwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract arrayExample { // public state variable uint[] public myArray; // Getter function generated by the compiler /* function myArray(uint i) public view returns (uint) { return myArray[i]; } */ // function that returns entire array function getArray() public view returns (uint[] memory) { return myArray; } } </pre></div> </div> Now you can use <code class="docutils literal notranslate">getArray()</code> to retrieve the entire array, instead of <code class="docutils literal notranslate">myArray(i)</code>, which returns a single element per call. The next example is more complex: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjAgPDAuOS4wOwoKY29udHJhY3QgQ29tcGxleCB7CiAgICBzdHJ1Y3QgRGF0YSB7CiAgICAgICAgdWludCBhOwogICAgICAgIGJ5dGVzMyBiOwogICAgICAgIG1hcHBpbmcodWludCA9PiB1aW50KSBtYXA7CiAgICAgICAgdWludFszXSBjOwogICAgICAgIHVpbnRbXSBkOwogICAgICAgIGJ5dGVzIGU7CiAgICB9CiAgICBtYXBwaW5nKHVpbnQgPT4gbWFwcGluZyhib29sID0+IERhdGFbXSkpIHB1YmxpYyBkYXRhOwp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.0 <0.9.0; contract Complex { struct Data { uint a; bytes3 b; mapping(uint => uint) map; uint[3] c; uint[] d; bytes e; } mapping(uint => mapping(bool => Data[])) public data; } </pre></div> </div> It generates a function of the following form. The mapping and arrays (with the exception of byte arrays) in the struct are omitted because there is no good way to select individual struct members or provide a key for the mapping: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=ZnVuY3Rpb24gZGF0YSh1aW50IGFyZzEsIGJvb2wgYXJnMiwgdWludCBhcmczKQogICAgcHVibGljCiAgICByZXR1cm5zICh1aW50IGEsIGJ5dGVzMyBiLCBieXRlcyBtZW1vcnkgZSkKewogICAgYSA9IGRhdGFbYXJnMV1bYXJnMl1bYXJnM10uYTsKICAgIGIgPSBkYXRhW2FyZzFdW2FyZzJdW2FyZzNdLmI7CiAgICBlID0gZGF0YVthcmcxXVthcmcyXVthcmczXS5lOwp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>function data(uint arg1, bool arg2, uint arg3) public returns (uint a, bytes3 b, bytes memory e) { a = data[arg1][arg2][arg3].a; b = data[arg1][arg2][arg3].b; e = data[arg1][arg2][arg3].e; } </pre></div> </div> </section> </section> <section id="function-modifiers"> <h2>Function Modifiers<a class="headerlink" href="#function-modifiers" title="Permalink to this heading"></a></h2> Modifiers can be used to change the behavior of functions in a declarative way. For example, you can use a modifier to automatically check a condition prior to executing the function. Modifiers are inheritable properties of contracts and may be overridden by derived contracts, but only if they are marked <code class="docutils literal notranslate">virtual</code>. For details, please see <a class="reference internal" href="#modifier-overriding">Modifier Overriding</a>. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=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" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.1 <0.9.0; contract owned { constructor() { owner = payable(msg.sender); } address payable owner; // This contract only defines a modifier but does not use // it: it will be used in derived contracts. // The function body is inserted where the special symbol // `_;` in the definition of a modifier appears. // This means that if the owner calls this function, the // function is executed and otherwise, an exception is // thrown. modifier onlyOwner { require( msg.sender == owner, "Only owner can call this function." ); _; } } contract priced { // Modifiers can receive arguments: modifier costs(uint price) { if (msg.value >= price) { _; } } } contract Register is priced, owned { mapping(address => bool) registeredAddresses; uint price; constructor(uint initialPrice) { price = initialPrice; } // It is important to also provide the // `payable` keyword here, otherwise the function will // automatically reject all Ether sent to it. function register() public payable costs(price) { registeredAddresses[msg.sender] = true; } // This contract inherits the `onlyOwner` modifier from // the `owned` contract. As a result, calls to `changePrice` will // only take effect if they are made by the stored owner. function changePrice(uint price_) public onlyOwner { price = price_; } } contract Mutex { bool locked; modifier noReentrancy() { require( !locked, "Reentrant call." ); locked = true; _; locked = false; } /// This function is protected by a mutex, which means that /// reentrant calls from within `msg.sender.call` cannot call `f` again. /// The `return 7` statement assigns 7 to the return value but still /// executes the statement `locked = false` in the modifier. function f() public noReentrancy returns (uint) { (bool success,) = msg.sender.call(""); require(success); return 7; } } </pre></div> </div> If you want to access a modifier <code class="docutils literal notranslate">m</code> defined in a contract <code class="docutils literal notranslate">C</code>, you can use <code class="docutils literal notranslate">C.m</code> to reference it without virtual lookup. It is only possible to use modifiers defined in the current contract or its base contracts. Modifiers can also be defined in libraries but their use is limited to functions of the same library. Multiple modifiers are applied to a function by specifying them in a whitespace-separated list and are evaluated in the order presented. Modifiers cannot implicitly access or change the arguments and return values of functions they modify. Their values can only be passed to them explicitly at the point of invocation. In function modifiers, it is necessary to specify when you want the function to which the modifier is applied to be run. The placeholder statement (denoted by a single underscore character <code class="docutils literal notranslate">_</code>) is used to denote where the body of the function being modified should be inserted. Note that the placeholder operator is different from using underscores as leading or trailing characters in variable names, which is a stylistic choice. Explicit returns from a modifier or function body only leave the current modifier or function body. Return variables are assigned and control flow continues after the <code class="docutils literal notranslate">_</code> in the preceding modifier. <div class="admonition warning"> Warning In an earlier version of Solidity, <code class="docutils literal notranslate">return</code> statements in functions having modifiers behaved differently. </div> An explicit return from a modifier with <code class="docutils literal notranslate">return;</code> does not affect the values returned by the function. The modifier can, however, choose not to execute the function body at all and in that case the return variables are set to their <a class="reference internal" href="control-structures.html#default-value">default values</a> just as if the function had an empty body. The <code class="docutils literal notranslate">_</code> symbol can appear in the modifier multiple times. Each occurrence is replaced with the function body, and the function returns the return value of the final occurrence. Arbitrary expressions are allowed for modifier arguments and in this context, all symbols visible from the function are visible in the modifier. Symbols introduced in the modifier are not visible in the function (as they might change by overriding). </section> <section id="transient-storage"> <h2>Transient Storage<a class="headerlink" href="#transient-storage" title="Permalink to this heading"></a></h2> Transient storage is another data location besides memory, storage, calldata (and return-data and code) which was introduced alongside its respective opcodes <code class="docutils literal notranslate">TSTORE</code> and <code class="docutils literal notranslate">TLOAD</code> by <a class="reference external" href="https://eips.ethereum.org/EIPS/eip-1153">EIP-1153</a>. This new data location behaves as a key-value store similar to storage with the main difference being that data in transient storage is not permanent, but is scoped to the current transaction only, after which it will be reset to zero. Since the content of transient storage has very limited lifetime and size, it does not need to be stored permanently as a part of state and the associated gas costs are much lower than in case of storage. EVM version <code class="docutils literal notranslate">cancun</code> or newer is required for transient storage to be available. Transient storage variables cannot be initialized in place, i.e., they cannot be assigned to upon declaration, since the value would be cleared at the end of the creation transaction, rendering the initialization ineffective. Transient variables will be <a class="reference internal" href="control-structures.html#default-value">default value</a> initialized depending on their underlying type. <code class="docutils literal notranslate">constant</code> and <code class="docutils literal notranslate">immutable</code> variables conflict with transient storage, since their values are either inlined or directly stored in code. Transient storage variables have completely independent address space from storage, so that the order of transient state variables does not affect the layout of storage state variables and vice-versa. They do need distinct names though because all state variables share the same namespace. It is also important to note that the values in transient storage are packed in the same fashion as those in persistent storage. See <a class="reference internal" href="internals/layout_in_storage.html#storage-inplace-encoding">Storage Layout</a> for more information. Besides that, transient variables can have visibility as well and <code class="docutils literal notranslate">public</code> ones will have a getter function generated automatically as usual. Note that, currently, such use of <code class="docutils literal notranslate">transient</code> as a data location is only allowed for <a class="reference internal" href="types.html#value-types">value type</a> state variable declarations. Reference types, such as arrays, mappings and structs, as well as local or parameter variables are not yet supported. An expected canonical use case for transient storage is cheaper reentrancy locks, which can be readily implemented with the opcodes as showcased next. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMjg7Cgpjb250cmFjdCBHZW5lcm9zaXR5IHsKICAgIG1hcHBpbmcoYWRkcmVzcyA9PiBib29sKSBzZW50R2lmdHM7CiAgICBib29sIHRyYW5zaWVudCBsb2NrZWQ7CgogICAgbW9kaWZpZXIgbm9uUmVlbnRyYW50IHsKICAgICAgICByZXF1aXJlKCFsb2NrZWQsICJSZWVudHJhbmN5IGF0dGVtcHQiKTsKICAgICAgICBsb2NrZWQgPSB0cnVlOwogICAgICAgIF87CiAgICAgICAgLy8gVW5sb2NrcyB0aGUgZ3VhcmQsIG1ha2luZyB0aGUgcGF0dGVybiBjb21wb3NhYmxlLgogICAgICAgIC8vIEFmdGVyIHRoZSBmdW5jdGlvbiBleGl0cywgaXQgY2FuIGJlIGNhbGxlZCBhZ2FpbiwgZXZlbiBpbiB0aGUgc2FtZSB0cmFuc2FjdGlvbi4KICAgICAgICBsb2NrZWQgPSBmYWxzZTsKICAgIH0KCiAgICBmdW5jdGlvbiBjbGFpbUdpZnQoKSBub25SZWVudHJhbnQgcHVibGljIHsKICAgICAgICByZXF1aXJlKGFkZHJlc3ModGhpcykuYmFsYW5jZSA+PSAxIGV0aGVyKTsKICAgICAgICByZXF1aXJlKCFzZW50R2lmdHNbbXNnLnNlbmRlcl0pOwogICAgICAgIChib29sIHN1Y2Nlc3MsICkgPSBtc2cuc2VuZGVyLmNhbGx7dmFsdWU6IDEgZXRoZXJ9KCIiKTsKICAgICAgICByZXF1aXJlKHN1Y2Nlc3MpOwoKICAgICAgICAvLyBJbiBhIHJlZW50cmFudCBmdW5jdGlvbiwgZG9pbmcgdGhpcyBsYXN0IHdvdWxkIG9wZW4gdXAgdGhlIHZ1bG5lcmFiaWxpdHkKICAgICAgICBzZW50R2lmdHNbbXNnLnNlbmRlcl0gPSB0cnVlOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.28; contract Generosity { mapping(address => bool) sentGifts; bool transient locked; modifier nonReentrant { require(!locked, "Reentrancy attempt"); locked = true; _; // Unlocks the guard, making the pattern composable. // After the function exits, it can be called again, even in the same transaction. locked = false; } function claimGift() nonReentrant public { require(address(this).balance >= 1 ether); require(!sentGifts[msg.sender]); (bool success, ) = msg.sender.call{value: 1 ether}(""); require(success); // In a reentrant function, doing this last would open up the vulnerability sentGifts[msg.sender] = true; } } </pre></div> </div> Transient storage is private to the contract that owns it, in the same way as persistent storage. Only owning contract frames may access their transient storage, and when they do, all the frames access the same transient store. Transient storage is part of the EVM state and is subject to the same mutability enforcements as persistent storage. As such, any read access to it is not <code class="docutils literal notranslate">pure</code> and writing access is not <code class="docutils literal notranslate">view</code>. If the <code class="docutils literal notranslate">TSTORE</code> opcode is called within the context of a <code class="docutils literal notranslate">STATICCALL</code>, it will result in an exception instead of performing the modification. <code class="docutils literal notranslate">TLOAD</code> is allowed within the context of a <code class="docutils literal notranslate">STATICCALL</code>. When transient storage is used in the context of <code class="docutils literal notranslate">DELEGATECALL</code> or <code class="docutils literal notranslate">CALLCODE</code>, then the owning contract of the transient storage is the contract that issued <code class="docutils literal notranslate">DELEGATECALL</code> or <code class="docutils literal notranslate">CALLCODE</code> instruction (the caller) as with persistent storage. When transient storage is used in the context of <code class="docutils literal notranslate">CALL</code> or <code class="docutils literal notranslate">STATICCALL</code>, then the owning contract of the transient storage is the contract that is the target of the <code class="docutils literal notranslate">CALL</code> or <code class="docutils literal notranslate">STATICCALL</code> instruction (the callee). <div class="admonition note"> Note In the case of <code class="docutils literal notranslate">DELEGATECALL</code>, since references to transient storage variables are currently not supported, it is not possible to pass those into library calls. In libraries, access to transient storage is only possible using inline assembly. </div> If a frame reverts, all writes to transient storage that took place between entry to the frame and the return are reverted, including those that took place in inner calls. The caller of an external call may employ a <code class="docutils literal notranslate">try ... catch</code> block to prevent reverts bubbling up from the inner calls. </section> <section id="composability-of-smart-contracts-and-the-caveats-of-transient-storage"> <h2>Composability of Smart Contracts and the Caveats of Transient Storage<a class="headerlink" href="#composability-of-smart-contracts-and-the-caveats-of-transient-storage" title="Permalink to this heading"></a></h2> Given the caveats mentioned in the specification of EIP-1153, in order to preserve the composability of your smart contract, utmost care is recommended for more advanced use cases of transient storage. For smart contracts, composability is a very important design principle to achieve self-contained behaviour, such that multiple calls into individual smart contracts can be composed to more complex applications. So far the EVM largely guaranteed composable behaviour, since multiple calls into a smart contract within a complex transaction are virtually indistinguishable from multiple calls to the contract stretched over several transactions. However, transient storage allows a violation of this principle, and incorrect use may lead to complex bugs that only surface when used across several calls. Let’s illustrate the problem with a simple example: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMjg7Cgpjb250cmFjdCBNdWxTZXJ2aWNlIHsKICAgIHVpbnQgdHJhbnNpZW50IG11bHRpcGxpZXI7CiAgICBmdW5jdGlvbiBzZXRNdWx0aXBsaWVyKHVpbnQgbXVsKSBleHRlcm5hbCB7CiAgICAgICAgbXVsdGlwbGllciA9IG11bDsKICAgIH0KCiAgICBmdW5jdGlvbiBtdWx0aXBseSh1aW50IHZhbHVlKSBleHRlcm5hbCB2aWV3IHJldHVybnMgKHVpbnQpIHsKICAgICAgICByZXR1cm4gdmFsdWUgKiBtdWx0aXBsaWVyOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.28; contract MulService { uint transient multiplier; function setMultiplier(uint mul) external { multiplier = mul; } function multiply(uint value) external view returns (uint) { return value * multiplier; } } </pre></div> </div> and a sequence of external calls: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=c2V0TXVsdGlwbGllcig0Mik7Cm11bHRpcGx5KDEpOwptdWx0aXBseSgyKTs=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>setMultiplier(42); multiply(1); multiply(2); </pre></div> </div> If the example used memory or storage to store the multiplier, it would be fully composable. It would not matter whether you split the sequence into separate transactions or grouped them in some way. You would always get the same result: after <code class="docutils literal notranslate">multiplier</code> is set to <code class="docutils literal notranslate">42</code>, the subsequent calls would return <code class="docutils literal notranslate">42</code> and <code class="docutils literal notranslate">84</code> respectively. This enables use cases such as batching calls from multiple transactions together to reduce gas costs. Transient storage potentially breaks such use cases since composability can no longer be taken for granted. In the example, if the calls are not executed in the same transaction, then <code class="docutils literal notranslate">multiplier</code> is reset and the next calls to function <code class="docutils literal notranslate">multiply</code> would always return <code class="docutils literal notranslate">0</code>. As another example, since transient storage is constructed as a relatively cheap key-value store, a smart contract author may be tempted to use transient storage as a replacement for in-memory mappings without keeping track of the modified keys in the mapping and thereby without clearing the mapping at the end of the call. This, however, can easily lead to unexpected behaviour in complex transactions, in which values set by a previous call into the contract within the same transaction remain. The use of transient storage for reentrancy locks that are cleared at the end of the call frame into the contract, is safe. However, be sure to resist the temptation to save the 100 gas used for resetting the reentrancy lock, since failing to do so, will restrict your contract to only one call within a transaction, preventing its use in complex composed transactions, which have been a cornerstone for complex applications on chain. It is recommend to generally always clear transient storage completely at the end of a call into your smart contract to avoid these kinds of issues and to simplify the analysis of the behaviour of your contract within complex transactions. Check the <a class="reference external" href="https://eips.ethereum.org/EIPS/eip-1153#security-considerations">Security Considerations section of EIP-1153</a> for further details. </section> <section id="constant-and-immutable-state-variables"> <h2>Constant and Immutable State Variables<a class="headerlink" href="#constant-and-immutable-state-variables" title="Permalink to this heading"></a></h2> State variables can be declared as <code class="docutils literal notranslate">constant</code> or <code class="docutils literal notranslate">immutable</code>. In both cases, the variables cannot be modified after the contract has been constructed. For <code class="docutils literal notranslate">constant</code> variables, the value has to be fixed at compile-time, while for <code class="docutils literal notranslate">immutable</code>, it can still be assigned at construction time. It is also possible to define <code class="docutils literal notranslate">constant</code> variables at the file level. Every occurrence of such a variable in the source is replaced by its underlying value and the compiler does not reserve a storage slot for it. It cannot be assigned a slot in transient storage using the <code class="docutils literal notranslate">transient</code> keyword either. Compared to regular state variables, the gas costs of constant and immutable variables are much lower. For a constant variable, the expression assigned to it is copied to all the places where it is accessed and also re-evaluated each time. This allows for local optimizations. Immutable variables are evaluated once at construction time and their value is copied to all the places in the code where they are accessed. For these values, 32 bytes are reserved, even if they would fit in fewer bytes. Due to this, constant values can sometimes be cheaper than immutable values. Not all types for constants and immutables are implemented at this time. The only supported types are <a class="reference internal" href="types.html#strings">strings</a> (only for constants) and <a class="reference internal" href="types.html#value-types">value types</a>. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMjE7Cgp1aW50IGNvbnN0YW50IFggPSAzMioqMjIgKyA4OwoKY29udHJhY3QgQyB7CiAgICBzdHJpbmcgY29uc3RhbnQgVEVYVCA9ICJhYmMiOwogICAgYnl0ZXMzMiBjb25zdGFudCBNWV9IQVNIID0ga2VjY2FrMjU2KCJhYmMiKTsKICAgIHVpbnQgaW1tdXRhYmxlIGRlY2ltYWxzID0gMTg7CiAgICB1aW50IGltbXV0YWJsZSBtYXhCYWxhbmNlOwogICAgYWRkcmVzcyBpbW11dGFibGUgb3duZXIgPSBtc2cuc2VuZGVyOwoKICAgIGNvbnN0cnVjdG9yKHVpbnQgZGVjaW1hbHNfLCBhZGRyZXNzIHJlZikgewogICAgICAgIGlmIChkZWNpbWFsc18gIT0gMCkKICAgICAgICAgICAgLy8gSW1tdXRhYmxlcyBhcmUgb25seSBpbW11dGFibGUgd2hlbiBkZXBsb3llZC4KICAgICAgICAgICAgLy8gQXQgY29uc3RydWN0aW9uIHRpbWUgdGhleSBjYW4gYmUgYXNzaWduZWQgdG8gYW55IG51bWJlciBvZiB0aW1lcy4KICAgICAgICAgICAgZGVjaW1hbHMgPSBkZWNpbWFsc187CgogICAgICAgIC8vIEFzc2lnbm1lbnRzIHRvIGltbXV0YWJsZXMgY2FuIGV2ZW4gYWNjZXNzIHRoZSBlbnZpcm9ubWVudC4KICAgICAgICBtYXhCYWxhbmNlID0gcmVmLmJhbGFuY2U7CiAgICB9CgogICAgZnVuY3Rpb24gaXNCYWxhbmNlVG9vSGlnaChhZGRyZXNzIG90aGVyKSBwdWJsaWMgdmlldyByZXR1cm5zIChib29sKSB7CiAgICAgICAgcmV0dXJuIG90aGVyLmJhbGFuY2UgPiBtYXhCYWxhbmNlOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.21; uint constant X = 32**22 + 8; contract C { string constant TEXT = "abc"; bytes32 constant MY_HASH = keccak256("abc"); uint immutable decimals = 18; uint immutable maxBalance; address immutable owner = msg.sender; constructor(uint decimals_, address ref) { if (decimals_ != 0) // Immutables are only immutable when deployed. // At construction time they can be assigned to any number of times. decimals = decimals_; // Assignments to immutables can even access the environment. maxBalance = ref.balance; } function isBalanceTooHigh(address other) public view returns (bool) { return other.balance > maxBalance; } } </pre></div> </div> <section id="constant"> <h3>Constant<a class="headerlink" href="#constant" title="Permalink to this heading"></a></h3> For <code class="docutils literal notranslate">constant</code> variables, the value has to be a constant at compile time and it has to be assigned where the variable is declared. Any expression that accesses storage, blockchain data (e.g. <code class="docutils literal notranslate">block.timestamp</code>, <code class="docutils literal notranslate">address(this).balance</code> or <code class="docutils literal notranslate">block.number</code>) or execution data (<code class="docutils literal notranslate">msg.value</code> or <code class="docutils literal notranslate">gasleft()</code>) or makes calls to external contracts is disallowed. Expressions that might have a side-effect on memory allocation are allowed, but those that might have a side-effect on other memory objects are not. The built-in functions <code class="docutils literal notranslate">keccak256</code>, <code class="docutils literal notranslate">sha256</code>, <code class="docutils literal notranslate">ripemd160</code>, <code class="docutils literal notranslate">ecrecover</code>, <code class="docutils literal notranslate">addmod</code> and <code class="docutils literal notranslate">mulmod</code> are allowed (even though, with the exception of <code class="docutils literal notranslate">keccak256</code>, they do call external contracts). The reason behind allowing side-effects on the memory allocator is that it should be possible to construct complex objects like e.g. lookup-tables. This feature is not yet fully usable. </section> <section id="immutable"> <h3>Immutable<a class="headerlink" href="#immutable" title="Permalink to this heading"></a></h3> Variables declared as <code class="docutils literal notranslate">immutable</code> are a bit less restricted than those declared as <code class="docutils literal notranslate">constant</code>: Immutable variables can be assigned a value at construction time. The value can be changed at any time before deployment and then it becomes permanent. One additional restriction is that immutables can only be assigned to inside expressions for which there is no possibility of being executed after creation. This excludes all modifier definitions and functions other than constructors. There are no restrictions on reading immutable variables. The read is even allowed to happen before the variable is written to for the first time because variables in Solidity always have a well-defined initial value. For this reason it is also allowed to never explicitly assign a value to an immutable. <div class="admonition warning"> Warning When accessing immutables at construction time, please keep the <a class="reference internal" href="ir-breaking-changes.html#state-variable-initialization-order">initialization order</a> in mind. Even if you provide an explicit initializer, some expressions may end up being evaluated before that initializer, especially when they are at a different level in inheritance hierarchy. </div> <div class="admonition note"> Note Before Solidity 0.8.21 initialization of immutable variables was more restrictive. Such variables had to be initialized exactly once at construction time and could not be read before then. </div> The contract creation code generated by the compiler will modify the contract’s runtime code before it is returned by replacing all references to immutables with the values assigned to them. This is important if you are comparing the runtime code generated by the compiler with the one actually stored in the blockchain. The compiler outputs where these immutables are located in the deployed bytecode in the <code class="docutils literal notranslate">immutableReferences</code> field of the <a class="reference internal" href="using-the-compiler.html#compiler-api">compiler JSON standard output</a>. </section> </section> <section id="functions"> <h2>Functions<a class="headerlink" href="#functions" title="Permalink to this heading"></a></h2> Functions can be defined inside and outside of contracts. Functions outside of a contract, also called “free functions”, always have implicit <code class="docutils literal notranslate">internal</code> <a class="reference internal" href="#visibility-and-getters">visibility</a>. Their code is included in all contracts that call them, similar to internal library functions. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjEgPDAuOS4wOwoKZnVuY3Rpb24gc3VtKHVpbnRbXSBtZW1vcnkgYXJyKSBwdXJlIHJldHVybnMgKHVpbnQgcykgewogICAgZm9yICh1aW50IGkgPSAwOyBpIDwgYXJyLmxlbmd0aDsgaSsrKQogICAgICAgIHMgKz0gYXJyW2ldOwp9Cgpjb250cmFjdCBBcnJheUV4YW1wbGUgewogICAgYm9vbCBmb3VuZDsKICAgIGZ1bmN0aW9uIGYodWludFtdIG1lbW9yeSBhcnIpIHB1YmxpYyB7CiAgICAgICAgLy8gVGhpcyBjYWxscyB0aGUgZnJlZSBmdW5jdGlvbiBpbnRlcm5hbGx5LgogICAgICAgIC8vIFRoZSBjb21waWxlciB3aWxsIGFkZCBpdHMgY29kZSB0byB0aGUgY29udHJhY3QuCiAgICAgICAgdWludCBzID0gc3VtKGFycik7CiAgICAgICAgcmVxdWlyZShzID49IDEwKTsKICAgICAgICBmb3VuZCA9IHRydWU7CiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.1 <0.9.0; function sum(uint[] memory arr) pure returns (uint s) { for (uint i = 0; i < arr.length; i++) s += arr[i]; } contract ArrayExample { bool found; function f(uint[] memory arr) public { // This calls the free function internally. // The compiler will add its code to the contract. uint s = sum(arr); require(s >= 10); found = true; } } </pre></div> </div> <div class="admonition note"> Note Functions defined outside a contract are still always executed in the context of a contract. They still can call other contracts, send them Ether and destroy the contract that called them, among other things. The main difference to functions defined inside a contract is that free functions do not have direct access to the variable <code class="docutils literal notranslate">this</code>, storage variables and functions not in their scope. </div> <section id="function-parameters-and-return-variables"> <h3>Function Parameters and Return Variables<a class="headerlink" href="#function-parameters-and-return-variables" title="Permalink to this heading"></a></h3> Functions take typed parameters as input and may, unlike in many other languages, also return an arbitrary number of values as output. <section id="function-parameters"> <h4>Function Parameters<a class="headerlink" href="#function-parameters" title="Permalink to this heading"></a></h4> Function parameters are declared the same way as variables, and the name of unused parameters can be omitted. For example, if you want your contract to accept one kind of external call with two integers, you would use something like the following: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IFNpbXBsZSB7CiAgICB1aW50IHN1bTsKICAgIGZ1bmN0aW9uIHRha2VyKHVpbnQgYSwgdWludCBiKSBwdWJsaWMgewogICAgICAgIHN1bSA9IGEgKyBiOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract Simple { uint sum; function taker(uint a, uint b) public { sum = a + b; } } </pre></div> </div> Function parameters can be used as any other local variable and they can also be assigned to. </section> <section id="return-variables"> <h4>Return Variables<a class="headerlink" href="#return-variables" title="Permalink to this heading"></a></h4> Function return variables are declared with the same syntax after the <code class="docutils literal notranslate">returns</code> keyword. For example, suppose you want to return two results: the sum and the product of two integers passed as function parameters, then you use something like: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IFNpbXBsZSB7CiAgICBmdW5jdGlvbiBhcml0aG1ldGljKHVpbnQgYSwgdWludCBiKQogICAgICAgIHB1YmxpYwogICAgICAgIHB1cmUKICAgICAgICByZXR1cm5zICh1aW50IHN1bSwgdWludCBwcm9kdWN0KQogICAgewogICAgICAgIHN1bSA9IGEgKyBiOwogICAgICAgIHByb2R1Y3QgPSBhICogYjsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract Simple { function arithmetic(uint a, uint b) public pure returns (uint sum, uint product) { sum = a + b; product = a * b; } } </pre></div> </div> The names of return variables can be omitted. Return variables can be used as any other local variable and they are initialized with their <a class="reference internal" href="control-structures.html#default-value">default value</a> and have that value until they are (re-)assigned. You can either explicitly assign to return variables and then leave the function as above, or you can provide return values (either a single or <a class="reference internal" href="#multi-return">multiple ones</a>) directly with the <code class="docutils literal notranslate">return</code> statement: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IFNpbXBsZSB7CiAgICBmdW5jdGlvbiBhcml0aG1ldGljKHVpbnQgYSwgdWludCBiKQogICAgICAgIHB1YmxpYwogICAgICAgIHB1cmUKICAgICAgICByZXR1cm5zICh1aW50IHN1bSwgdWludCBwcm9kdWN0KQogICAgewogICAgICAgIHJldHVybiAoYSArIGIsIGEgKiBiKTsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract Simple { function arithmetic(uint a, uint b) public pure returns (uint sum, uint product) { return (a + b, a * b); } } </pre></div> </div> If you use an early <code class="docutils literal notranslate">return</code> to leave a function that has return variables, you must provide return values together with the return statement. <div class="admonition note"> Note You cannot return some types from non-internal functions. This includes the types listed below and any composite types that recursively contain them: <ul class="simple"> <li>mappings,</li> <li>internal function types,</li> <li>reference types with location set to <code class="docutils literal notranslate">storage</code>,</li> <li>multi-dimensional arrays (applies only to <a class="reference internal" href="layout-of-source-files.html#abi-coder">ABI coder v1</a>),</li> <li>structs (applies only to <a class="reference internal" href="layout-of-source-files.html#abi-coder">ABI coder v1</a>).</li> </ul> This restriction does not apply to library functions because of their different <a class="reference internal" href="#library-selectors">internal ABI</a>. </div> </section> <section id="returning-multiple-values"> <h4>Returning Multiple Values<a class="headerlink" href="#returning-multiple-values" title="Permalink to this heading"></a></h4> When a function has multiple return types, the statement <code class="docutils literal notranslate">return (v0, v1, ..., vn)</code> can be used to return multiple values. The number of components must be the same as the number of return variables and their types have to match, potentially after an <a class="reference internal" href="types.html#types-conversion-elementary-types">implicit conversion</a>. </section> </section> <section id="state-mutability"> <h3>State Mutability<a class="headerlink" href="#state-mutability" title="Permalink to this heading"></a></h3> <section id="view-functions"> <h4>View Functions<a class="headerlink" href="#view-functions" title="Permalink to this heading"></a></h4> Functions can be declared <code class="docutils literal notranslate">view</code> in which case they promise not to modify the state. <div class="admonition note"> Note If the compiler’s EVM target is Byzantium or newer (default) the opcode <code class="docutils literal notranslate">STATICCALL</code> is used when <code class="docutils literal notranslate">view</code> functions are called, which enforces the state to stay unmodified as part of the EVM execution. For library <code class="docutils literal notranslate">view</code> functions <code class="docutils literal notranslate">DELEGATECALL</code> is used, because there is no combined <code class="docutils literal notranslate">DELEGATECALL</code> and <code class="docutils literal notranslate">STATICCALL</code>. This means library <code class="docutils literal notranslate">view</code> functions do not have run-time checks that prevent state modifications. This should not impact security negatively because library code is usually known at compile-time and the static checker performs compile-time checks. </div> The following statements are considered modifying the state: <ol class="arabic simple"> <li>Writing to state variables (storage and transient storage).</li> <li><a class="reference internal" href="#events">Emitting events</a>.</li> <li><a class="reference internal" href="control-structures.html#creating-contracts">Creating other contracts</a>.</li> <li>Using <code class="docutils literal notranslate">selfdestruct</code>.</li> <li>Sending Ether via calls.</li> <li>Calling any function not marked <code class="docutils literal notranslate">view</code> or <code class="docutils literal notranslate">pure</code>.</li> <li>Using low-level calls.</li> <li>Using inline assembly that contains certain opcodes.</li> </ol> <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC41LjAgPDAuOS4wOwoKY29udHJhY3QgQyB7CiAgICBmdW5jdGlvbiBmKHVpbnQgYSwgdWludCBiKSBwdWJsaWMgdmlldyByZXR1cm5zICh1aW50KSB7CiAgICAgICAgcmV0dXJuIGEgKiAoYiArIDQyKSArIGJsb2NrLnRpbWVzdGFtcDsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.5.0 <0.9.0; contract C { function f(uint a, uint b) public view returns (uint) { return a * (b + 42) + block.timestamp; } } </pre></div> </div> <div class="admonition note"> Note <code class="docutils literal notranslate">constant</code> on functions used to be an alias to <code class="docutils literal notranslate">view</code>, but this was dropped in version 0.5.0. </div> <div class="admonition note"> Note Getter methods are automatically marked <code class="docutils literal notranslate">view</code>. </div> <div class="admonition note"> Note Prior to version 0.5.0, the compiler did not use the <code class="docutils literal notranslate">STATICCALL</code> opcode for <code class="docutils literal notranslate">view</code> functions. This enabled state modifications in <code class="docutils literal notranslate">view</code> functions through the use of invalid explicit type conversions. By using <code class="docutils literal notranslate">STATICCALL</code> for <code class="docutils literal notranslate">view</code> functions, modifications to the state are prevented on the level of the EVM. </div> </section> <section id="pure-functions"> <h4>Pure Functions<a class="headerlink" href="#pure-functions" title="Permalink to this heading"></a></h4> Functions can be declared <code class="docutils literal notranslate">pure</code> in which case they promise not to read from or modify the state. In particular, it should be possible to evaluate a <code class="docutils literal notranslate">pure</code> function at compile-time given only its inputs and <code class="docutils literal notranslate">msg.data</code>, but without any knowledge of the current blockchain state. This means that reading from <code class="docutils literal notranslate">immutable</code> variables can be a non-pure operation. <div class="admonition note"> Note If the compiler’s EVM target is Byzantium or newer (default) the opcode <code class="docutils literal notranslate">STATICCALL</code> is used, which does not guarantee that the state is not read, but at least that it is not modified. </div> In addition to the list of state modifying statements explained above, the following are considered reading from the state: <ol class="arabic simple"> <li>Reading from state variables (storage and transient storage).</li> <li>Accessing <code class="docutils literal notranslate">address(this).balance</code> or <code class="docutils literal notranslate"><address>.balance</code>.</li> <li>Accessing any of the members of <code class="docutils literal notranslate">block</code>, <code class="docutils literal notranslate">tx</code>, <code class="docutils literal notranslate">msg</code> (with the exception of <code class="docutils literal notranslate">msg.sig</code> and <code class="docutils literal notranslate">msg.data</code>).</li> <li>Calling any function not marked <code class="docutils literal notranslate">pure</code>.</li> <li>Using inline assembly that contains certain opcodes.</li> </ol> <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC41LjAgPDAuOS4wOwoKY29udHJhY3QgQyB7CiAgICBmdW5jdGlvbiBmKHVpbnQgYSwgdWludCBiKSBwdWJsaWMgcHVyZSByZXR1cm5zICh1aW50KSB7CiAgICAgICAgcmV0dXJuIGEgKiAoYiArIDQyKTsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.5.0 <0.9.0; contract C { function f(uint a, uint b) public pure returns (uint) { return a * (b + 42); } } </pre></div> </div> Pure functions are able to use the <code class="docutils literal notranslate">revert()</code> and <code class="docutils literal notranslate">require()</code> functions to revert potential state changes when an <a class="reference internal" href="control-structures.html#assert-and-require">error occurs</a>. Reverting a state change is not considered a “state modification”, as only changes to the state made previously in code that did not have the <code class="docutils literal notranslate">view</code> or <code class="docutils literal notranslate">pure</code> restriction are reverted and that code has the option to catch the <code class="docutils literal notranslate">revert</code> and not pass it on. This behavior is also in line with the <code class="docutils literal notranslate">STATICCALL</code> opcode. <div class="admonition warning"> Warning It is not possible to prevent functions from reading the state at the level of the EVM, it is only possible to prevent them from writing to the state (i.e. only <code class="docutils literal notranslate">view</code> can be enforced at the EVM level, <code class="docutils literal notranslate">pure</code> can not). </div> <div class="admonition note"> Note Prior to version 0.5.0, the compiler did not use the <code class="docutils literal notranslate">STATICCALL</code> opcode for <code class="docutils literal notranslate">pure</code> functions. This enabled state modifications in <code class="docutils literal notranslate">pure</code> functions through the use of invalid explicit type conversions. By using <code class="docutils literal notranslate">STATICCALL</code> for <code class="docutils literal notranslate">pure</code> functions, modifications to the state are prevented on the level of the EVM. </div> <div class="admonition note"> Note Prior to version 0.4.17 the compiler did not enforce that <code class="docutils literal notranslate">pure</code> is not reading the state. It is a compile-time type check, which can be circumvented by doing invalid explicit conversions between contract types, because the compiler can verify that the type of the contract does not do state-changing operations, but it cannot check that the contract that will be called at runtime is actually of that type. </div> </section> </section> <section id="special-functions"> <h3>Special Functions<a class="headerlink" href="#special-functions" title="Permalink to this heading"></a></h3> <section id="receive-ether-function"> <h4>Receive Ether Function<a class="headerlink" href="#receive-ether-function" title="Permalink to this heading"></a></h4> A contract can have at most one <code class="docutils literal notranslate">receive</code> function, declared using <code class="docutils literal notranslate">receive() external payable { ... }</code> (without the <code class="docutils literal notranslate">function</code> keyword). This function cannot have arguments, cannot return anything and must have <code class="docutils literal notranslate">external</code> visibility and <code class="docutils literal notranslate">payable</code> state mutability. It can be virtual, can override and can have modifiers. The receive function is executed on a call to the contract with empty calldata. This is the function that is executed on plain Ether transfers (e.g. via <code class="docutils literal notranslate">.send()</code> or <code class="docutils literal notranslate">.transfer()</code>). If no such function exists, but a payable <a class="reference internal" href="#fallback-function">fallback function</a> exists, the fallback function will be called on a plain Ether transfer. If neither a receive Ether nor a payable fallback function is present, the contract cannot receive Ether through a transaction that does not represent a payable function call and throws an exception. In the worst case, the <code class="docutils literal notranslate">receive</code> function can only rely on 2300 gas being available (for example when <code class="docutils literal notranslate">send</code> or <code class="docutils literal notranslate">transfer</code> is used), leaving little room to perform other operations except basic logging. The following operations will consume more gas than the 2300 gas stipend: <ul class="simple"> <li>Writing to storage</li> <li>Creating a contract</li> <li>Calling an external function which consumes a large amount of gas</li> <li>Sending Ether</li> </ul> <div class="admonition warning"> Warning When Ether is sent directly to a contract (without a function call, i.e. sender uses <code class="docutils literal notranslate">send</code> or <code class="docutils literal notranslate">transfer</code>) but the receiving contract does not define a receive Ether function or a payable fallback function, an exception will be thrown, sending back the Ether (this was different before Solidity v0.4.0). If you want your contract to receive Ether, you have to implement a receive Ether function (using payable fallback functions for receiving Ether is not recommended, since the fallback is invoked and would not fail for interface confusions on the part of the sender). </div> <div class="admonition warning"> Warning A contract without a receive Ether function can receive Ether as a recipient of a coinbase transaction (aka miner block reward) or as a destination of a <code class="docutils literal notranslate">selfdestruct</code>. A contract cannot react to such Ether transfers and thus also cannot reject them. This is a design choice of the EVM and Solidity cannot work around it. It also means that <code class="docutils literal notranslate">address(this).balance</code> can be higher than the sum of some manual accounting implemented in a contract (i.e. having a counter updated in the receive Ether function). </div> Below you can see an example of a Sink contract that uses function <code class="docutils literal notranslate">receive</code>. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKLy8gVGhpcyBjb250cmFjdCBrZWVwcyBhbGwgRXRoZXIgc2VudCB0byBpdCB3aXRoIG5vIHdheQovLyB0byBnZXQgaXQgYmFjay4KY29udHJhY3QgU2luayB7CiAgICBldmVudCBSZWNlaXZlZChhZGRyZXNzLCB1aW50KTsKICAgIHJlY2VpdmUoKSBleHRlcm5hbCBwYXlhYmxlIHsKICAgICAgICBlbWl0IFJlY2VpdmVkKG1zZy5zZW5kZXIsIG1zZy52YWx1ZSk7CiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; // This contract keeps all Ether sent to it with no way // to get it back. contract Sink { event Received(address, uint); receive() external payable { emit Received(msg.sender, msg.value); } } </pre></div> </div> </section> <section id="fallback-function"> <h4>Fallback Function<a class="headerlink" href="#fallback-function" title="Permalink to this heading"></a></h4> A contract can have at most one <code class="docutils literal notranslate">fallback</code> function, declared using either <code class="docutils literal notranslate">fallback () external [payable]</code> or <code class="docutils literal notranslate">fallback (bytes calldata input) external [payable] returns (bytes memory output)</code> (both without the <code class="docutils literal notranslate">function</code> keyword). This function must have <code class="docutils literal notranslate">external</code> visibility. A fallback function can be virtual, can override and can have modifiers. The fallback function is executed on a call to the contract if none of the other functions match the given function signature, or if no data was supplied at all and there is no <a class="reference internal" href="#receive-ether-function">receive Ether function</a>. The fallback function always receives data, but in order to also receive Ether it must be marked <code class="docutils literal notranslate">payable</code>. If the version with parameters is used, <code class="docutils literal notranslate">input</code> will contain the full data sent to the contract (equal to <code class="docutils literal notranslate">msg.data</code>) and can return data in <code class="docutils literal notranslate">output</code>. The returned data will not be ABI-encoded. Instead it will be returned without modifications (not even padding). In the worst case, if a payable fallback function is also used in place of a receive function, it can only rely on 2300 gas being available (see <a class="reference internal" href="#receive-ether-function">receive Ether function</a> for a brief description of the implications of this). Like any function, the fallback function can execute complex operations as long as there is enough gas passed on to it. <div class="admonition warning"> Warning A <code class="docutils literal notranslate">payable</code> fallback function is also executed for plain Ether transfers, if no <a class="reference internal" href="#receive-ether-function">receive Ether function</a> is present. It is recommended to always define a receive Ether function as well, if you define a payable fallback function to distinguish Ether transfers from interface confusions. </div> <div class="admonition note"> Note If you want to decode the input data, you can check the first four bytes for the function selector and then you can use <code class="docutils literal notranslate">abi.decode</code> together with the array slice syntax to decode ABI-encoded data: <code class="docutils literal notranslate">(c, d) = abi.decode(input[4:], (uint256, uint256));</code> Note that this should only be used as a last resort and proper functions should be used instead. </div> <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=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" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.2 <0.9.0; contract Test { uint x; // This function is called for all messages sent to // this contract (there is no other function). // Sending Ether to this contract will cause an exception, // because the fallback function does not have the `payable` // modifier. fallback() external { x = 1; } } contract TestPayable { uint x; uint y; // This function is called for all messages sent to // this contract, except plain Ether transfers // (there is no other function except the receive function). // Any call with non-empty calldata to this contract will execute // the fallback function (even if Ether is sent along with the call). fallback() external payable { x = 1; y = msg.value; } // This function is called for plain Ether transfers, i.e. // for every call with empty calldata. receive() external payable { x = 2; y = msg.value; } } contract Caller { function callTest(Test test) public returns (bool) { (bool success,) = address(test).call(abi.encodeWithSignature("nonExistingFunction()")); require(success); // results in test.x becoming == 1. // address(test) will not allow to call ``send`` directly, since ``test`` has no payable // fallback function. // It has to be converted to the ``address payable`` type to even allow calling ``send`` on it. address payable testPayable = payable(address(test)); // If someone sends Ether to that contract, // the transfer will fail, i.e. this returns false here. return testPayable.send(2 ether); } function callTestPayable(TestPayable test) public returns (bool) { (bool success,) = address(test).call(abi.encodeWithSignature("nonExistingFunction()")); require(success); // results in test.x becoming == 1 and test.y becoming 0. (success,) = address(test).call{value: 1}(abi.encodeWithSignature("nonExistingFunction()")); require(success); // results in test.x becoming == 1 and test.y becoming 1. // If someone sends Ether to that contract, the receive function in TestPayable will be called. // Since that function writes to storage, it takes more gas than is available with a // simple ``send`` or ``transfer``. Because of that, we have to use a low-level call. (success,) = address(test).call{value: 2 ether}(""); require(success); // results in test.x becoming == 2 and test.y becoming 2 ether. return true; } } </pre></div> </div> </section> </section> <section id="function-overloading"> <h3>Function Overloading<a class="headerlink" href="#function-overloading" title="Permalink to this heading"></a></h3> A contract can have multiple functions of the same name but with different parameter types. This process is called “overloading” and also applies to inherited functions. The following example shows overloading of the function <code class="docutils literal notranslate">f</code> in the scope of contract <code class="docutils literal notranslate">A</code>. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IEEgewogICAgZnVuY3Rpb24gZih1aW50IHZhbHVlKSBwdWJsaWMgcHVyZSByZXR1cm5zICh1aW50IG91dCkgewogICAgICAgIG91dCA9IHZhbHVlOwogICAgfQoKICAgIGZ1bmN0aW9uIGYodWludCB2YWx1ZSwgYm9vbCByZWFsbHkpIHB1YmxpYyBwdXJlIHJldHVybnMgKHVpbnQgb3V0KSB7CiAgICAgICAgaWYgKHJlYWxseSkKICAgICAgICAgICAgb3V0ID0gdmFsdWU7CiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract A { function f(uint value) public pure returns (uint out) { out = value; } function f(uint value, bool really) public pure returns (uint out) { if (really) out = value; } } </pre></div> </div> Overloaded functions are also present in the external interface. It is an error if two externally visible functions differ by their Solidity types but not by their external types. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCi8vIFRoaXMgd2lsbCBub3QgY29tcGlsZQpjb250cmFjdCBBIHsKICAgIGZ1bmN0aW9uIGYoQiB2YWx1ZSkgcHVibGljIHB1cmUgcmV0dXJucyAoQiBvdXQpIHsKICAgICAgICBvdXQgPSB2YWx1ZTsKICAgIH0KCiAgICBmdW5jdGlvbiBmKGFkZHJlc3MgdmFsdWUpIHB1YmxpYyBwdXJlIHJldHVybnMgKGFkZHJlc3Mgb3V0KSB7CiAgICAgICAgb3V0ID0gdmFsdWU7CiAgICB9Cn0KCmNvbnRyYWN0IEIgewp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; // This will not compile contract A { function f(B value) public pure returns (B out) { out = value; } function f(address value) public pure returns (address out) { out = value; } } contract B { } </pre></div> </div> Both <code class="docutils literal notranslate">f</code> function overloads above end up accepting the address type for the ABI although they are considered different inside Solidity. <section id="overload-resolution-and-argument-matching"> <h4>Overload resolution and Argument matching<a class="headerlink" href="#overload-resolution-and-argument-matching" title="Permalink to this heading"></a></h4> Overloaded functions are selected by matching the function declarations in the current scope to the arguments supplied in the function call. Functions are selected as overload candidates if all arguments can be implicitly converted to the expected types. If there is not exactly one candidate, resolution fails. <div class="admonition note"> Note Return parameters are not taken into account for overload resolution. </div> <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjE2IDwwLjkuMDsKCmNvbnRyYWN0IEEgewogICAgZnVuY3Rpb24gZih1aW50OCB2YWwpIHB1YmxpYyBwdXJlIHJldHVybnMgKHVpbnQ4IG91dCkgewogICAgICAgIG91dCA9IHZhbDsKICAgIH0KCiAgICBmdW5jdGlvbiBmKHVpbnQyNTYgdmFsKSBwdWJsaWMgcHVyZSByZXR1cm5zICh1aW50MjU2IG91dCkgewogICAgICAgIG91dCA9IHZhbDsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.16 <0.9.0; contract A { function f(uint8 val) public pure returns (uint8 out) { out = val; } function f(uint256 val) public pure returns (uint256 out) { out = val; } } </pre></div> </div> Calling <code class="docutils literal notranslate">f(50)</code> would create a type error since <code class="docutils literal notranslate">50</code> can be implicitly converted both to <code class="docutils literal notranslate">uint8</code> and <code class="docutils literal notranslate">uint256</code> types. On another hand <code class="docutils literal notranslate">f(256)</code> would resolve to <code class="docutils literal notranslate">f(uint256)</code> overload as <code class="docutils literal notranslate">256</code> cannot be implicitly converted to <code class="docutils literal notranslate">uint8</code>. </section> </section> </section> <section id="events"> <h2>Events<a class="headerlink" href="#events" title="Permalink to this heading"></a></h2> Solidity events give an abstraction on top of the EVM’s logging functionality. Applications can subscribe and listen to these events through the RPC interface of an Ethereum client. Events can be defined at file level or as inheritable members of contracts (including interfaces and libraries). When you call them, they cause the arguments to be stored in the transaction’s log - a special data structure in the blockchain. These logs are associated with the address of the contract that emitted them, are incorporated into the blockchain, and stay there as long as a block is accessible (forever as of now, but this might change in the future). The Log and its event data is not accessible from within contracts (not even from the contract that created them). It is possible to request a Merkle proof for logs, so if an external entity supplies a contract with such a proof, it can check that the log actually exists inside the blockchain. You have to supply block headers because the contract can only see the last 256 block hashes. You can add the attribute <code class="docutils literal notranslate">indexed</code> to up to three parameters which adds them to a special data structure known as <a class="reference internal" href="abi-spec.html#abi-events">“topics”</a> instead of the data part of the log. A topic can only hold a single word (32 bytes) so if you use a <a class="reference internal" href="types.html#reference-types">reference type</a> for an indexed argument, the Keccak-256 hash of the value is stored as a topic instead. All parameters without the <code class="docutils literal notranslate">indexed</code> attribute are <a class="reference internal" href="abi-spec.html#abi">ABI-encoded</a> into the data part of the log. Topics allow you to search for events, for example when filtering a sequence of blocks for certain events. You can also filter events by the address of the contract that emitted the event. For example, the code below uses the web3.js <code class="docutils literal notranslate">subscribe("logs")</code> <a class="reference external" href="https://web3js.readthedocs.io/en/1.0/web3-eth-subscribe.html#subscribe-logs">method</a> to filter logs that match a topic with a certain address value: <div class="highlight-javascript notranslate"><div class="highlight"><pre>var options = { fromBlock: 0, address: web3.eth.defaultAccount, topics: ["0x0000000000000000000000000000000000000000000000000000000000000000", null, null] }; web3.eth.subscribe('logs', options, function (error, result) { if (!error) console.log(result); }) .on("data", function (log) { console.log(log); }) .on("changed", function (log) { }); </pre></div> </div> The hash of the signature of the event is one of the topics, except if you declared the event with the <code class="docutils literal notranslate">anonymous</code> specifier. This means that it is not possible to filter for specific anonymous events by name, you can only filter by the contract address. The advantage of anonymous events is that they are cheaper to deploy and call. It also allows you to declare four indexed arguments rather than three. <div class="admonition note"> Note Since the transaction log only stores the event data and not the type, you have to know the type of the event, including which parameter is indexed and if the event is anonymous in order to correctly interpret the data. In particular, it is possible to “fake” the signature of another event using an anonymous event. </div> <section id="members-of-events"> <h3>Members of Events<a class="headerlink" href="#members-of-events" title="Permalink to this heading"></a></h3> <ul class="simple"> <li><code class="docutils literal notranslate">event.selector</code>: For non-anonymous events, this is a <code class="docutils literal notranslate">bytes32</code> value containing the <code class="docutils literal notranslate">keccak256</code> hash of the event signature, as used in the default topic.</li> </ul> </section> <section id="example"> <h3>Example<a class="headerlink" href="#example" title="Permalink to this heading"></a></h3> <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjIxIDwwLjkuMDsKCmNvbnRyYWN0IENsaWVudFJlY2VpcHQgewogICAgZXZlbnQgRGVwb3NpdCgKICAgICAgICBhZGRyZXNzIGluZGV4ZWQgZnJvbSwKICAgICAgICBieXRlczMyIGluZGV4ZWQgaWQsCiAgICAgICAgdWludCB2YWx1ZQogICAgKTsKCiAgICBmdW5jdGlvbiBkZXBvc2l0KGJ5dGVzMzIgaWQpIHB1YmxpYyBwYXlhYmxlIHsKICAgICAgICAvLyBFdmVudHMgYXJlIGVtaXR0ZWQgdXNpbmcgYGVtaXRgLCBmb2xsb3dlZCBieQogICAgICAgIC8vIHRoZSBuYW1lIG9mIHRoZSBldmVudCBhbmQgdGhlIGFyZ3VtZW50cwogICAgICAgIC8vIChpZiBhbnkpIGluIHBhcmVudGhlc2VzLiBBbnkgc3VjaCBpbnZvY2F0aW9uCiAgICAgICAgLy8gKGV2ZW4gZGVlcGx5IG5lc3RlZCkgY2FuIGJlIGRldGVjdGVkIGZyb20KICAgICAgICAvLyB0aGUgSmF2YVNjcmlwdCBBUEkgYnkgZmlsdGVyaW5nIGZvciBgRGVwb3NpdGAuCiAgICAgICAgZW1pdCBEZXBvc2l0KG1zZy5zZW5kZXIsIGlkLCBtc2cudmFsdWUpOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.21 <0.9.0; contract ClientReceipt { event Deposit( address indexed from, bytes32 indexed id, uint value ); function deposit(bytes32 id) public payable { // Events are emitted using `emit`, followed by // the name of the event and the arguments // (if any) in parentheses. Any such invocation // (even deeply nested) can be detected from // the JavaScript API by filtering for `Deposit`. emit Deposit(msg.sender, id, msg.value); } } </pre></div> </div> The use in the JavaScript API is as follows: <div class="highlight-javascript notranslate"><div class="highlight"><pre>var abi = /* abi as generated by the compiler */; var ClientReceipt = web3.eth.contract(abi); var clientReceipt = ClientReceipt.at("0x1234...ab67" /* address */); var depositEvent = clientReceipt.Deposit(); // watch for changes depositEvent.watch(function(error, result){ // result contains non-indexed arguments and topics // given to the `Deposit` call. if (!error) console.log(result); }); // Or pass a callback to start watching immediately var depositEvent = clientReceipt.Deposit(function(error, result) { if (!error) console.log(result); }); </pre></div> </div> The output of the above looks like the following (trimmed): <div class="highlight-json notranslate"><div class="highlight"><pre>{ "returnValues": { "from": "0x1111…FFFFCCCC", "id": "0x50…sd5adb20", "value": "0x420042" }, "raw": { "data": "0x7f…91385", "topics": ["0xfd4…b4ead7", "0x7f…1a91385"] } } </pre></div> </div> </section> <section id="additional-resources-for-understanding-events"> <h3>Additional Resources for Understanding Events<a class="headerlink" href="#additional-resources-for-understanding-events" title="Permalink to this heading"></a></h3> <ul class="simple"> <li><a class="reference external" href="https://github.com/web3/web3.js/blob/1.x/docs/web3-eth-contract.rst#events">JavaScript documentation</a></li> <li><a class="reference external" href="https://github.com/ethchange/smart-exchange/blob/master/lib/contracts/SmartExchange.sol">Example usage of events</a></li> <li><a class="reference external" href="https://github.com/ethchange/smart-exchange/blob/master/lib/exchange_transactions.js">How to access them in js</a></li> </ul> </section> </section> <section id="custom-errors"> <h2>Custom Errors<a class="headerlink" href="#custom-errors" title="Permalink to this heading"></a></h2> Errors in Solidity provide a convenient and gas-efficient way to explain to the user why an operation failed. They can be defined inside and outside of contracts (including interfaces and libraries). They have to be used together with the <a class="reference internal" href="control-structures.html#revert-statement">revert statement</a> or the <a class="reference internal" href="control-structures.html#assert-and-require-statements">require function</a>. In the case of <code class="docutils literal notranslate">revert</code> statements, or <code class="docutils literal notranslate">require</code> calls where the condition is evaluated to be false, all changes in the current call are reverted, and the error data passed back to the caller. The example below shows custom error usage with the <code class="docutils literal notranslate">revert</code> statement in function <code class="docutils literal notranslate">transferWithRevertError</code>, as well as the newer approach with <code class="docutils literal notranslate">require</code> in function <code class="docutils literal notranslate">transferWithRequireError</code>. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMjc7CgovLy8gSW5zdWZmaWNpZW50IGJhbGFuY2UgZm9yIHRyYW5zZmVyLiBOZWVkZWQgYHJlcXVpcmVkYCBidXQgb25seQovLy8gYGF2YWlsYWJsZWAgYXZhaWxhYmxlLgovLy8gQHBhcmFtIGF2YWlsYWJsZSBiYWxhbmNlIGF2YWlsYWJsZS4KLy8vIEBwYXJhbSByZXF1aXJlZCByZXF1ZXN0ZWQgYW1vdW50IHRvIHRyYW5zZmVyLgplcnJvciBJbnN1ZmZpY2llbnRCYWxhbmNlKHVpbnQyNTYgYXZhaWxhYmxlLCB1aW50MjU2IHJlcXVpcmVkKTsKCmNvbnRyYWN0IFRlc3RUb2tlbiB7CiAgICBtYXBwaW5nKGFkZHJlc3MgPT4gdWludCkgYmFsYW5jZTsKICAgIGZ1bmN0aW9uIHRyYW5zZmVyV2l0aFJldmVydEVycm9yKGFkZHJlc3MgdG8sIHVpbnQyNTYgYW1vdW50KSBwdWJsaWMgewogICAgICAgIGlmIChhbW91bnQgPiBiYWxhbmNlW21zZy5zZW5kZXJdKQogICAgICAgICAgICByZXZlcnQgSW5zdWZmaWNpZW50QmFsYW5jZSh7CiAgICAgICAgICAgICAgICBhdmFpbGFibGU6IGJhbGFuY2VbbXNnLnNlbmRlcl0sCiAgICAgICAgICAgICAgICByZXF1aXJlZDogYW1vdW50CiAgICAgICAgICAgIH0pOwogICAgICAgIGJhbGFuY2VbbXNnLnNlbmRlcl0gLT0gYW1vdW50OwogICAgICAgIGJhbGFuY2VbdG9dICs9IGFtb3VudDsKICAgIH0KICAgIGZ1bmN0aW9uIHRyYW5zZmVyV2l0aFJlcXVpcmVFcnJvcihhZGRyZXNzIHRvLCB1aW50MjU2IGFtb3VudCkgcHVibGljIHsKICAgICAgICByZXF1aXJlKGFtb3VudCA8PSBiYWxhbmNlW21zZy5zZW5kZXJdLCBJbnN1ZmZpY2llbnRCYWxhbmNlKGJhbGFuY2VbbXNnLnNlbmRlcl0sIGFtb3VudCkpOwogICAgICAgIGJhbGFuY2VbbXNnLnNlbmRlcl0gLT0gYW1vdW50OwogICAgICAgIGJhbGFuY2VbdG9dICs9IGFtb3VudDsKICAgIH0KICAgIC8vIC4uLgp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.27; /// Insufficient balance for transfer. Needed `required` but only /// `available` available. /// @param available balance available. /// @param required requested amount to transfer. error InsufficientBalance(uint256 available, uint256 required); contract TestToken { mapping(address => uint) balance; function transferWithRevertError(address to, uint256 amount) public { if (amount > balance[msg.sender]) revert InsufficientBalance({ available: balance[msg.sender], required: amount }); balance[msg.sender] -= amount; balance[to] += amount; } function transferWithRequireError(address to, uint256 amount) public { require(amount <= balance[msg.sender], InsufficientBalance(balance[msg.sender], amount)); balance[msg.sender] -= amount; balance[to] += amount; } // ... } </pre></div> </div> Another important detail to mention when it comes to using <code class="docutils literal notranslate">require</code> with custom errors, is that memory allocation for the error-based revert reason will only happen in the reverting case, which, along with optimization of constants and string literals makes this about as gas-efficient as the <code class="docutils literal notranslate">if (!condition) revert CustomError(args)</code> pattern. Errors cannot be overloaded or overridden but are inherited. The same error can be defined in multiple places as long as the scopes are distinct. Instances of errors can only be created using <code class="docutils literal notranslate">revert</code> statements, or as the second argument to <code class="docutils literal notranslate">require</code> functions. The error creates data that is then passed to the caller with the revert operation to either return to the off-chain component or catch it in a <a class="reference internal" href="control-structures.html#try-catch">try/catch statement</a>. Note that an error can only be caught when coming from an external call, reverts happening in internal calls or inside the same function cannot be caught. If you do not provide any parameters, the error only needs four bytes of data and you can use <a class="reference internal" href="natspec-format.html#natspec">NatSpec</a> as above to further explain the reasons behind the error, which is not stored on chain. This makes this a very cheap and convenient error-reporting feature at the same time. More specifically, an error instance is ABI-encoded in the same way as a function call to a function of the same name and types would be and then used as the return data in the <code class="docutils literal notranslate">revert</code> opcode. This means that the data consists of a 4-byte selector followed by <a class="reference internal" href="abi-spec.html#abi">ABI-encoded</a> data. The selector consists of the first four bytes of the keccak256-hash of the signature of the error type. <div class="admonition note"> Note It is possible for a contract to revert with different errors of the same name or even with errors defined in different places that are indistinguishable by the caller. For the outside, i.e. the ABI, only the name of the error is relevant, not the contract or file where it is defined. </div> The statement <code class="docutils literal notranslate">require(condition, "description");</code> would be equivalent to <code class="docutils literal notranslate">if (!condition) revert Error("description")</code> if you could define <code class="docutils literal notranslate">error Error(string)</code>. Note, however, that <code class="docutils literal notranslate">Error</code> is a built-in type and cannot be defined in user-supplied code. Similarly, a failing <code class="docutils literal notranslate">assert</code> or similar conditions will revert with an error of the built-in type <code class="docutils literal notranslate">Panic(uint256)</code>. <div class="admonition note"> Note Error data should only be used to give an indication of failure, but not as a means for control-flow. The reason is that the revert data of inner calls is propagated back through the chain of external calls by default. This means that an inner call can “forge” revert data that looks like it could have come from the contract that called it. </div> <section id="members-of-errors"> <h3>Members of Errors<a class="headerlink" href="#members-of-errors" title="Permalink to this heading"></a></h3> <ul class="simple"> <li><code class="docutils literal notranslate">error.selector</code>: A <code class="docutils literal notranslate">bytes4</code> value containing the error selector.</li> </ul> </section> </section> <section id="inheritance"> <h2>Inheritance<a class="headerlink" href="#inheritance" title="Permalink to this heading"></a></h2> Solidity supports multiple inheritance including polymorphism. Polymorphism means that a function call (internal and external) always executes the function of the same name (and parameter types) in the most derived contract in the inheritance hierarchy. This has to be explicitly enabled on each function in the hierarchy using the <code class="docutils literal notranslate">virtual</code> and <code class="docutils literal notranslate">override</code> keywords. See <a class="reference internal" href="#function-overriding">Function Overriding</a> for more details. It is possible to call functions further up in the inheritance hierarchy internally by explicitly specifying the contract using <code class="docutils literal notranslate">ContractName.functionName()</code> or using <code class="docutils literal notranslate">super.functionName()</code> if you want to call the function one level higher up in the flattened inheritance hierarchy (see below). When a contract inherits from other contracts, only a single contract is created on the blockchain, and the code from all the base contracts is compiled into the created contract. This means that all internal calls to functions of base contracts also just use internal function calls (<code class="docutils literal notranslate">super.f(..)</code> will use JUMP and not a message call). State variable shadowing is considered as an error. A derived contract can only declare a state variable <code class="docutils literal notranslate">x</code>, if there is no visible state variable with the same name in any of its bases. The general inheritance system is very similar to <a class="reference external" href="https://docs.python.org/3/tutorial/classes.html#inheritance">Python’s</a>, especially concerning multiple inheritance, but there are also some <a class="reference internal" href="#multi-inheritance">differences</a>. Details are given in the following example. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=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" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; contract Owned { address payable owner; constructor() { owner = payable(msg.sender); } } // Use `is` to derive from another contract. Derived // contracts can access all non-private members including // internal functions and state variables. These cannot be // accessed externally via `this`, though. contract Emittable is Owned { event Emitted(); // The keyword `virtual` means that the function can change // its behavior in derived classes ("overriding"). function emitEvent() virtual public { if (msg.sender == owner) emit Emitted(); } } // These abstract contracts are only provided to make the // interface known to the compiler. Note the function // without body. If a contract does not implement all // functions it can only be used as an interface. abstract contract Config { function lookup(uint id) public virtual returns (address adr); } abstract contract NameReg { function register(bytes32 name) public virtual; function unregister() public virtual; } // Multiple inheritance is possible. Note that `Owned` is // also a base class of `Emittable`, yet there is only a single // instance of `Owned` (as for virtual inheritance in C++). contract Named is Owned, Emittable { constructor(bytes32 name) { Config config = Config(0xD5f9D8D94886E70b06E474c3fB14Fd43E2f23970); NameReg(config.lookup(1)).register(name); } // Functions can be overridden by another function with the same name and // the same number/types of inputs. If the overriding function has different // types of output parameters, that causes an error. // Both local and message-based function calls take these overrides // into account. // If you want the function to override, you need to use the // `override` keyword. You need to specify the `virtual` keyword again // if you want this function to be overridden again. function emitEvent() public virtual override { if (msg.sender == owner) { Config config = Config(0xD5f9D8D94886E70b06E474c3fB14Fd43E2f23970); NameReg(config.lookup(1)).unregister(); // It is still possible to call a specific // overridden function. Emittable.emitEvent(); } } } // If a constructor takes an argument, it needs to be // provided in the header or modifier-invocation-style at // the constructor of the derived contract (see below). contract PriceFeed is Owned, Emittable, Named("GoldFeed") { uint info; function updateInfo(uint newInfo) public { if (msg.sender == owner) info = newInfo; } // Here, we only specify `override` and not `virtual`. // This means that contracts deriving from `PriceFeed` // cannot change the behavior of `emitEvent` anymore. function emitEvent() public override(Emittable, Named) { Named.emitEvent(); } function get() public view returns(uint r) { return info; } } </pre></div> </div> Note that above, we call <code class="docutils literal notranslate">Emittable.emitEvent()</code> to “forward” the emit event request. The way this is done is problematic, as seen in the following example: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjAgPDAuOS4wOwoKY29udHJhY3QgT3duZWQgewogICAgYWRkcmVzcyBwYXlhYmxlIG93bmVyOwogICAgY29uc3RydWN0b3IoKSB7IG93bmVyID0gcGF5YWJsZShtc2cuc2VuZGVyKTsgfQp9Cgpjb250cmFjdCBFbWl0dGFibGUgaXMgT3duZWQgewogICAgZXZlbnQgRW1pdHRlZCgpOwoKICAgIGZ1bmN0aW9uIGVtaXRFdmVudCgpIHZpcnR1YWwgcHVibGljIHsKICAgICAgICBpZiAobXNnLnNlbmRlciA9PSBvd25lcikgewogICAgICAgICAgICBlbWl0IEVtaXR0ZWQoKTsKICAgICAgICB9CiAgICB9Cn0KCmNvbnRyYWN0IEJhc2UxIGlzIEVtaXR0YWJsZSB7CiAgICBldmVudCBCYXNlMUVtaXR0ZWQoKTsKICAgIGZ1bmN0aW9uIGVtaXRFdmVudCgpIHB1YmxpYyB2aXJ0dWFsIG92ZXJyaWRlIHsKICAgICAgICAvKiBIZXJlLCB3ZSBlbWl0IGFuIGV2ZW50IHRvIHNpbXVsYXRlIHNvbWUgQmFzZTEgbG9naWMgKi8KICAgICAgICBlbWl0IEJhc2UxRW1pdHRlZCgpOwogICAgICAgIEVtaXR0YWJsZS5lbWl0RXZlbnQoKTsKICAgIH0KfQoKY29udHJhY3QgQmFzZTIgaXMgRW1pdHRhYmxlIHsKICAgIGV2ZW50IEJhc2UyRW1pdHRlZCgpOwogICAgZnVuY3Rpb24gZW1pdEV2ZW50KCkgcHVibGljIHZpcnR1YWwgb3ZlcnJpZGUgewogICAgICAgIC8qIEhlcmUsIHdlIGVtaXQgYW4gZXZlbnQgdG8gc2ltdWxhdGUgc29tZSBCYXNlMiBsb2dpYyAqLwogICAgICAgIGVtaXQgQmFzZTJFbWl0dGVkKCk7CiAgICAgICAgRW1pdHRhYmxlLmVtaXRFdmVudCgpOwogICAgfQp9Cgpjb250cmFjdCBGaW5hbCBpcyBCYXNlMSwgQmFzZTIgewogICAgZXZlbnQgRmluYWxFbWl0dGVkKCk7CiAgICBmdW5jdGlvbiBlbWl0RXZlbnQoKSBwdWJsaWMgb3ZlcnJpZGUoQmFzZTEsIEJhc2UyKSB7CiAgICAgICAgLyogSGVyZSwgd2UgZW1pdCBhbiBldmVudCB0byBzaW11bGF0ZSBzb21lIEZpbmFsIGxvZ2ljICovCiAgICAgICAgZW1pdCBGaW5hbEVtaXR0ZWQoKTsKICAgICAgICBCYXNlMi5lbWl0RXZlbnQoKTsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; contract Owned { address payable owner; constructor() { owner = payable(msg.sender); } } contract Emittable is Owned { event Emitted(); function emitEvent() virtual public { if (msg.sender == owner) { emit Emitted(); } } } contract Base1 is Emittable { event Base1Emitted(); function emitEvent() public virtual override { /* Here, we emit an event to simulate some Base1 logic */ emit Base1Emitted(); Emittable.emitEvent(); } } contract Base2 is Emittable { event Base2Emitted(); function emitEvent() public virtual override { /* Here, we emit an event to simulate some Base2 logic */ emit Base2Emitted(); Emittable.emitEvent(); } } contract Final is Base1, Base2 { event FinalEmitted(); function emitEvent() public override(Base1, Base2) { /* Here, we emit an event to simulate some Final logic */ emit FinalEmitted(); Base2.emitEvent(); } } </pre></div> </div> A call to <code class="docutils literal notranslate">Final.emitEvent()</code> will call <code class="docutils literal notranslate">Base2.emitEvent</code> because we specify it explicitly in the final override, but this function will bypass <code class="docutils literal notranslate">Base1.emitEvent</code>, resulting in the following sequence of events: <code class="docutils literal notranslate">FinalEmitted -> Base2Emitted -> Emitted</code>, instead of the expected sequence: <code class="docutils literal notranslate">FinalEmitted -> Base2Emitted -> Base1Emitted -> Emitted</code>. The way around this is to use <code class="docutils literal notranslate">super</code>: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjAgPDAuOS4wOwoKY29udHJhY3QgT3duZWQgewogICAgYWRkcmVzcyBwYXlhYmxlIG93bmVyOwogICAgY29uc3RydWN0b3IoKSB7IG93bmVyID0gcGF5YWJsZShtc2cuc2VuZGVyKTsgfQp9Cgpjb250cmFjdCBFbWl0dGFibGUgaXMgT3duZWQgewogICAgZXZlbnQgRW1pdHRlZCgpOwoKICAgIGZ1bmN0aW9uIGVtaXRFdmVudCgpIHZpcnR1YWwgcHVibGljIHsKICAgICAgICBpZiAobXNnLnNlbmRlciA9PSBvd25lcikgewogICAgICAgICAgICBlbWl0IEVtaXR0ZWQoKTsKICAgICAgICB9CiAgICB9Cn0KCmNvbnRyYWN0IEJhc2UxIGlzIEVtaXR0YWJsZSB7CiAgICBldmVudCBCYXNlMUVtaXR0ZWQoKTsKICAgIGZ1bmN0aW9uIGVtaXRFdmVudCgpIHB1YmxpYyB2aXJ0dWFsIG92ZXJyaWRlIHsKICAgICAgICAvKiBIZXJlLCB3ZSBlbWl0IGFuIGV2ZW50IHRvIHNpbXVsYXRlIHNvbWUgQmFzZTEgbG9naWMgKi8KICAgICAgICBlbWl0IEJhc2UxRW1pdHRlZCgpOwogICAgICAgIHN1cGVyLmVtaXRFdmVudCgpOwogICAgfQp9CgoKY29udHJhY3QgQmFzZTIgaXMgRW1pdHRhYmxlIHsKICAgIGV2ZW50IEJhc2UyRW1pdHRlZCgpOwogICAgZnVuY3Rpb24gZW1pdEV2ZW50KCkgcHVibGljIHZpcnR1YWwgb3ZlcnJpZGUgewogICAgICAgIC8qIEhlcmUsIHdlIGVtaXQgYW4gZXZlbnQgdG8gc2ltdWxhdGUgc29tZSBCYXNlMiBsb2dpYyAqLwogICAgICAgIGVtaXQgQmFzZTJFbWl0dGVkKCk7CiAgICAgICAgc3VwZXIuZW1pdEV2ZW50KCk7CiAgICB9Cn0KCmNvbnRyYWN0IEZpbmFsIGlzIEJhc2UxLCBCYXNlMiB7CiAgICBldmVudCBGaW5hbEVtaXR0ZWQoKTsKICAgIGZ1bmN0aW9uIGVtaXRFdmVudCgpIHB1YmxpYyBvdmVycmlkZShCYXNlMSwgQmFzZTIpIHsKICAgICAgICAvKiBIZXJlLCB3ZSBlbWl0IGFuIGV2ZW50IHRvIHNpbXVsYXRlIHNvbWUgRmluYWwgbG9naWMgKi8KICAgICAgICBlbWl0IEZpbmFsRW1pdHRlZCgpOwogICAgICAgIHN1cGVyLmVtaXRFdmVudCgpOwogICAgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; contract Owned { address payable owner; constructor() { owner = payable(msg.sender); } } contract Emittable is Owned { event Emitted(); function emitEvent() virtual public { if (msg.sender == owner) { emit Emitted(); } } } contract Base1 is Emittable { event Base1Emitted(); function emitEvent() public virtual override { /* Here, we emit an event to simulate some Base1 logic */ emit Base1Emitted(); super.emitEvent(); } } contract Base2 is Emittable { event Base2Emitted(); function emitEvent() public virtual override { /* Here, we emit an event to simulate some Base2 logic */ emit Base2Emitted(); super.emitEvent(); } } contract Final is Base1, Base2 { event FinalEmitted(); function emitEvent() public override(Base1, Base2) { /* Here, we emit an event to simulate some Final logic */ emit FinalEmitted(); super.emitEvent(); } } </pre></div> </div> If <code class="docutils literal notranslate">Final</code> calls a function of <code class="docutils literal notranslate">super</code>, it does not simply call this function on one of its base contracts. Rather, it calls this function on the next base contract in the final inheritance graph, so it will call <code class="docutils literal notranslate">Base1.emitEvent()</code> (note that the final inheritance sequence is – starting with the most derived contract: Final, Base2, Base1, Emittable, Owned). The actual function that is called when using super is not known in the context of the class where it is used, although its type is known. This is similar for ordinary virtual method lookup. <section id="function-overriding"> <h3>Function Overriding<a class="headerlink" href="#function-overriding" title="Permalink to this heading"></a></h3> Base functions can be overridden by inheriting contracts to change their behavior if they are marked as <code class="docutils literal notranslate">virtual</code>. The overriding function must then use the <code class="docutils literal notranslate">override</code> keyword in the function header. The overriding function may only change the visibility of the overridden function from <code class="docutils literal notranslate">external</code> to <code class="docutils literal notranslate">public</code>. The mutability may be changed to a more strict one following the order: <code class="docutils literal notranslate">nonpayable</code> can be overridden by <code class="docutils literal notranslate">view</code> and <code class="docutils literal notranslate">pure</code>. <code class="docutils literal notranslate">view</code> can be overridden by <code class="docutils literal notranslate">pure</code>. <code class="docutils literal notranslate">payable</code> is an exception and cannot be changed to any other mutability. The following example demonstrates changing mutability and visibility: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjAgPDAuOS4wOwoKY29udHJhY3QgQmFzZQp7CiAgICBmdW5jdGlvbiBmb28oKSB2aXJ0dWFsIGV4dGVybmFsIHZpZXcge30KfQoKY29udHJhY3QgTWlkZGxlIGlzIEJhc2Uge30KCmNvbnRyYWN0IEluaGVyaXRlZCBpcyBNaWRkbGUKewogICAgZnVuY3Rpb24gZm9vKCkgb3ZlcnJpZGUgcHVibGljIHB1cmUge30KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; contract Base { function foo() virtual external view {} } contract Middle is Base {} contract Inherited is Middle { function foo() override public pure {} } </pre></div> </div> For multiple inheritance, the most derived base contracts that define the same function must be specified explicitly after the <code class="docutils literal notranslate">override</code> keyword. In other words, you have to specify all base contracts that define the same function and have not yet been overridden by another base contract (on some path through the inheritance graph). Additionally, if a contract inherits the same function from multiple (unrelated) bases, it has to explicitly override it: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKY29udHJhY3QgQmFzZTEKewogICAgZnVuY3Rpb24gZm9vKCkgdmlydHVhbCBwdWJsaWMge30KfQoKY29udHJhY3QgQmFzZTIKewogICAgZnVuY3Rpb24gZm9vKCkgdmlydHVhbCBwdWJsaWMge30KfQoKY29udHJhY3QgSW5oZXJpdGVkIGlzIEJhc2UxLCBCYXNlMgp7CiAgICAvLyBEZXJpdmVzIGZyb20gbXVsdGlwbGUgYmFzZXMgZGVmaW5pbmcgZm9vKCksIHNvIHdlIG11c3QgZXhwbGljaXRseQogICAgLy8gb3ZlcnJpZGUgaXQKICAgIGZ1bmN0aW9uIGZvbygpIHB1YmxpYyBvdmVycmlkZShCYXNlMSwgQmFzZTIpIHt9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; contract Base1 { function foo() virtual public {} } contract Base2 { function foo() virtual public {} } contract Inherited is Base1, Base2 { // Derives from multiple bases defining foo(), so we must explicitly // override it function foo() public override(Base1, Base2) {} } </pre></div> </div> An explicit override specifier is not required if the function is defined in a common base contract or if there is a unique function in a common base contract that already overrides all other functions. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKY29udHJhY3QgQSB7IGZ1bmN0aW9uIGYoKSBwdWJsaWMgcHVyZXt9IH0KY29udHJhY3QgQiBpcyBBIHt9CmNvbnRyYWN0IEMgaXMgQSB7fQovLyBObyBleHBsaWNpdCBvdmVycmlkZSByZXF1aXJlZApjb250cmFjdCBEIGlzIEIsIEMge30=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; contract A { function f() public pure{} } contract B is A {} contract C is A {} // No explicit override required contract D is B, C {} </pre></div> </div> More formally, it is not required to override a function (directly or indirectly) inherited from multiple bases if there is a base contract that is part of all override paths for the signature, and (1) that base implements the function and no paths from the current contract to the base mentions a function with that signature or (2) that base does not implement the function and there is at most one mention of the function in all paths from the current contract to that base. In this sense, an override path for a signature is a path through the inheritance graph that starts at the contract under consideration and ends at a contract mentioning a function with that signature that does not override. If you do not mark a function that overrides as <code class="docutils literal notranslate">virtual</code>, derived contracts can no longer change the behavior of that function. <div class="admonition note"> Note Functions with the <code class="docutils literal notranslate">private</code> visibility cannot be <code class="docutils literal notranslate">virtual</code>. </div> <div class="admonition note"> Note Functions without implementation have to be marked <code class="docutils literal notranslate">virtual</code> outside of interfaces. In interfaces, all functions are automatically considered <code class="docutils literal notranslate">virtual</code>. </div> <div class="admonition note"> Note Starting from Solidity 0.8.8, the <code class="docutils literal notranslate">override</code> keyword is not required when overriding an interface function, except for the case where the function is defined in multiple bases. </div> Public state variables can override external functions if the parameter and return types of the function matches the getter function of the variable: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKY29udHJhY3QgQQp7CiAgICBmdW5jdGlvbiBmKCkgZXh0ZXJuYWwgdmlldyB2aXJ0dWFsIHJldHVybnModWludCkgeyByZXR1cm4gNTsgfQp9Cgpjb250cmFjdCBCIGlzIEEKewogICAgdWludCBwdWJsaWMgb3ZlcnJpZGUgZjsKfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; contract A { function f() external view virtual returns(uint) { return 5; } } contract B is A { uint public override f; } </pre></div> </div> <div class="admonition note"> Note While public state variables can override external functions, they themselves cannot be overridden. </div> </section> <section id="modifier-overriding"> <h3>Modifier Overriding<a class="headerlink" href="#modifier-overriding" title="Permalink to this heading"></a></h3> Function modifiers can override each other. This works in the same way as <a class="reference internal" href="#function-overriding">function overriding</a> (except that there is no overloading for modifiers). The <code class="docutils literal notranslate">virtual</code> keyword must be used on the overridden modifier and the <code class="docutils literal notranslate">override</code> keyword must be used in the overriding modifier: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKY29udHJhY3QgQmFzZQp7CiAgICBtb2RpZmllciBmb28oKSB2aXJ0dWFsIHtfO30KfQoKY29udHJhY3QgSW5oZXJpdGVkIGlzIEJhc2UKewogICAgbW9kaWZpZXIgZm9vKCkgb3ZlcnJpZGUge187fQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; contract Base { modifier foo() virtual {_;} } contract Inherited is Base { modifier foo() override {_;} } </pre></div> </div> In case of multiple inheritance, all direct base contracts must be specified explicitly: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKY29udHJhY3QgQmFzZTEKewogICAgbW9kaWZpZXIgZm9vKCkgdmlydHVhbCB7Xzt9Cn0KCmNvbnRyYWN0IEJhc2UyCnsKICAgIG1vZGlmaWVyIGZvbygpIHZpcnR1YWwge187fQp9Cgpjb250cmFjdCBJbmhlcml0ZWQgaXMgQmFzZTEsIEJhc2UyCnsKICAgIG1vZGlmaWVyIGZvbygpIG92ZXJyaWRlKEJhc2UxLCBCYXNlMikge187fQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; contract Base1 { modifier foo() virtual {_;} } contract Base2 { modifier foo() virtual {_;} } contract Inherited is Base1, Base2 { modifier foo() override(Base1, Base2) {_;} } </pre></div> </div> </section> <section id="constructors"> <h3>Constructors<a class="headerlink" href="#constructors" title="Permalink to this heading"></a></h3> A constructor is an optional function declared with the <code class="docutils literal notranslate">constructor</code> keyword which is executed upon contract creation, and where you can run contract initialization code. Before the constructor code is executed, state variables are initialised to their specified value if you initialise them inline, or their <a class="reference internal" href="control-structures.html#default-value">default value</a> if you do not. After the constructor has run, the final code of the contract is deployed to the blockchain. The deployment of the code costs additional gas linear to the length of the code. This code includes all functions that are part of the public interface and all functions that are reachable from there through function calls. It does not include the constructor code or internal functions that are only called from the constructor. If there is no constructor, the contract will assume the default constructor, which is equivalent to <code class="docutils literal notranslate">constructor() {}</code>. For example: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjAgPDAuOS4wOwoKYWJzdHJhY3QgY29udHJhY3QgQSB7CiAgICB1aW50IHB1YmxpYyBhOwoKICAgIGNvbnN0cnVjdG9yKHVpbnQgYV8pIHsKICAgICAgICBhID0gYV87CiAgICB9Cn0KCmNvbnRyYWN0IEIgaXMgQSgxKSB7CiAgICBjb25zdHJ1Y3RvcigpIHt9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; abstract contract A { uint public a; constructor(uint a_) { a = a_; } } contract B is A(1) { constructor() {} } </pre></div> </div> You can use internal parameters in a constructor (for example storage pointers). In this case, the contract has to be marked <a class="reference internal" href="#abstract-contract">abstract</a>, because these parameters cannot be assigned valid values from outside but only through the constructors of derived contracts. <div class="admonition warning"> Warning Prior to version 0.4.22, constructors were defined as functions with the same name as the contract. This syntax was deprecated and is not allowed anymore in version 0.5.0. </div> <div class="admonition warning"> Warning Prior to version 0.7.0, you had to specify the visibility of constructors as either <code class="docutils literal notranslate">internal</code> or <code class="docutils literal notranslate">public</code>. </div> </section> <section id="arguments-for-base-constructors"> <h3>Arguments for Base Constructors<a class="headerlink" href="#arguments-for-base-constructors" title="Permalink to this heading"></a></h3> The constructors of all the base contracts will be called following the linearization rules explained below. If the base constructors have arguments, derived contracts need to specify all of them. This can be done in two ways: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjAgPDAuOS4wOwoKY29udHJhY3QgQmFzZSB7CiAgICB1aW50IHg7CiAgICBjb25zdHJ1Y3Rvcih1aW50IHhfKSB7IHggPSB4XzsgfQp9CgovLyBFaXRoZXIgZGlyZWN0bHkgc3BlY2lmeSBpbiB0aGUgaW5oZXJpdGFuY2UgbGlzdC4uLgpjb250cmFjdCBEZXJpdmVkMSBpcyBCYXNlKDcpIHsKICAgIGNvbnN0cnVjdG9yKCkge30KfQoKLy8gb3IgdGhyb3VnaCBhICJtb2RpZmllciIgb2YgdGhlIGRlcml2ZWQgY29uc3RydWN0b3IuLi4KY29udHJhY3QgRGVyaXZlZDIgaXMgQmFzZSB7CiAgICBjb25zdHJ1Y3Rvcih1aW50IHkpIEJhc2UoeSAqIHkpIHt9Cn0KCi8vIG9yIGRlY2xhcmUgYWJzdHJhY3QuLi4KYWJzdHJhY3QgY29udHJhY3QgRGVyaXZlZDMgaXMgQmFzZSB7Cn0KCi8vIGFuZCBoYXZlIHRoZSBuZXh0IGNvbmNyZXRlIGRlcml2ZWQgY29udHJhY3QgaW5pdGlhbGl6ZSBpdC4KY29udHJhY3QgRGVyaXZlZEZyb21EZXJpdmVkIGlzIERlcml2ZWQzIHsKICAgIGNvbnN0cnVjdG9yKCkgQmFzZSgxMCArIDEwKSB7fQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; contract Base { uint x; constructor(uint x_) { x = x_; } } // Either directly specify in the inheritance list... contract Derived1 is Base(7) { constructor() {} } // or through a "modifier" of the derived constructor... contract Derived2 is Base { constructor(uint y) Base(y * y) {} } // or declare abstract... abstract contract Derived3 is Base { } // and have the next concrete derived contract initialize it. contract DerivedFromDerived is Derived3 { constructor() Base(10 + 10) {} } </pre></div> </div> One way is directly in the inheritance list (<code class="docutils literal notranslate">is Base(7)</code>). The other is in the way a modifier is invoked as part of the derived constructor (<code class="docutils literal notranslate">Base(y * y)</code>). The first way to do it is more convenient if the constructor argument is a constant and defines the behavior of the contract or describes it. The second way has to be used if the constructor arguments of the base depend on those of the derived contract. Arguments have to be given either in the inheritance list or in modifier-style in the derived constructor. Specifying arguments in both places is an error. If a derived contract does not specify the arguments to all of its base contracts’ constructors, it must be declared abstract. In that case, when another contract derives from it, that other contract’s inheritance list or constructor must provide the necessary parameters for all base classes that haven’t had their parameters specified (otherwise, that other contract must be declared abstract as well). For example, in the above code snippet, see <code class="docutils literal notranslate">Derived3</code> and <code class="docutils literal notranslate">DerivedFromDerived</code>. </section> <section id="multiple-inheritance-and-linearization"> <h3>Multiple Inheritance and Linearization<a class="headerlink" href="#multiple-inheritance-and-linearization" title="Permalink to this heading"></a></h3> Languages that allow multiple inheritance have to deal with several problems. One is the <a class="reference external" href="https://en.wikipedia.org/wiki/Multiple_inheritance#The_diamond_problem">Diamond Problem</a>. Solidity is similar to Python in that it uses “<a class="reference external" href="https://en.wikipedia.org/wiki/C3_linearization">C3 Linearization</a>” to force a specific order in the directed acyclic graph (DAG) of base classes. This results in the desirable property of monotonicity but disallows some inheritance graphs. Especially, the order in which the base classes are given in the <code class="docutils literal notranslate">is</code> directive is important: You have to list the direct base contracts in the order from “most base-like” to “most derived”. Note that this order is the reverse of the one used in Python. Another simplifying way to explain this is that when a function is called that is defined multiple times in different contracts, the given bases are searched from right to left (left to right in Python) in a depth-first manner, stopping at the first match. If a base contract has already been searched, it is skipped. In the following code, Solidity will give the error “Linearization of inheritance graph impossible”. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC40LjAgPDAuOS4wOwoKY29udHJhY3QgWCB7fQpjb250cmFjdCBBIGlzIFgge30KLy8gVGhpcyB3aWxsIG5vdCBjb21waWxlCmNvbnRyYWN0IEMgaXMgQSwgWCB7fQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.4.0 <0.9.0; contract X {} contract A is X {} // This will not compile contract C is A, X {} </pre></div> </div> The reason for this is that <code class="docutils literal notranslate">C</code> requests <code class="docutils literal notranslate">X</code> to override <code class="docutils literal notranslate">A</code> (by specifying <code class="docutils literal notranslate">A, X</code> in this order), but <code class="docutils literal notranslate">A</code> itself requests to override <code class="docutils literal notranslate">X</code>, which is a contradiction that cannot be resolved. Due to the fact that you have to explicitly override a function that is inherited from multiple bases without a unique override, C3 linearization is not too important in practice. One area where inheritance linearization is especially important and perhaps not as clear is when there are multiple constructors in the inheritance hierarchy. The constructors will always be executed in the linearized order, regardless of the order in which their arguments are provided in the inheriting contract’s constructor. For example: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC43LjAgPDAuOS4wOwoKY29udHJhY3QgQmFzZTEgewogICAgY29uc3RydWN0b3IoKSB7fQp9Cgpjb250cmFjdCBCYXNlMiB7CiAgICBjb25zdHJ1Y3RvcigpIHt9Cn0KCi8vIENvbnN0cnVjdG9ycyBhcmUgZXhlY3V0ZWQgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKLy8gIDEgLSBCYXNlMQovLyAgMiAtIEJhc2UyCi8vICAzIC0gRGVyaXZlZDEKY29udHJhY3QgRGVyaXZlZDEgaXMgQmFzZTEsIEJhc2UyIHsKICAgIGNvbnN0cnVjdG9yKCkgQmFzZTEoKSBCYXNlMigpIHt9Cn0KCi8vIENvbnN0cnVjdG9ycyBhcmUgZXhlY3V0ZWQgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKLy8gIDEgLSBCYXNlMgovLyAgMiAtIEJhc2UxCi8vICAzIC0gRGVyaXZlZDIKY29udHJhY3QgRGVyaXZlZDIgaXMgQmFzZTIsIEJhc2UxIHsKICAgIGNvbnN0cnVjdG9yKCkgQmFzZTIoKSBCYXNlMSgpIHt9Cn0KCi8vIENvbnN0cnVjdG9ycyBhcmUgc3RpbGwgZXhlY3V0ZWQgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKLy8gIDEgLSBCYXNlMgovLyAgMiAtIEJhc2UxCi8vICAzIC0gRGVyaXZlZDMKY29udHJhY3QgRGVyaXZlZDMgaXMgQmFzZTIsIEJhc2UxIHsKICAgIGNvbnN0cnVjdG9yKCkgQmFzZTEoKSBCYXNlMigpIHt9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0; contract Base1 { constructor() {} } contract Base2 { constructor() {} } // Constructors are executed in the following order: // 1 - Base1 // 2 - Base2 // 3 - Derived1 contract Derived1 is Base1, Base2 { constructor() Base1() Base2() {} } // Constructors are executed in the following order: // 1 - Base2 // 2 - Base1 // 3 - Derived2 contract Derived2 is Base2, Base1 { constructor() Base2() Base1() {} } // Constructors are still executed in the following order: // 1 - Base2 // 2 - Base1 // 3 - Derived3 contract Derived3 is Base2, Base1 { constructor() Base1() Base2() {} } </pre></div> </div> </section> <section id="inheriting-different-kinds-of-members-of-the-same-name"> <h3>Inheriting Different Kinds of Members of the Same Name<a class="headerlink" href="#inheriting-different-kinds-of-members-of-the-same-name" title="Permalink to this heading"></a></h3> The only situations where, due to inheritance, a contract may contain multiple definitions sharing the same name are: <ul class="simple"> <li>Overloading of functions.</li> <li>Overriding of virtual functions.</li> <li>Overriding of external virtual functions by state variable getters.</li> <li>Overriding of virtual modifiers.</li> <li>Overloading of events.</li> </ul> </section> </section> <section id="abstract-contracts"> <h2>Abstract Contracts<a class="headerlink" href="#abstract-contracts" title="Permalink to this heading"></a></h2> Contracts must be marked as abstract when at least one of their functions is not implemented or when they do not provide arguments for all of their base contract constructors. Even if this is not the case, a contract may still be marked abstract, such as when you do not intend for the contract to be created directly. Abstract contracts are similar to <a class="reference internal" href="#interfaces">Interfaces</a> but an interface is more limited in what it can declare. An abstract contract is declared using the <code class="docutils literal notranslate">abstract</code> keyword as shown in the following example. Note that this contract needs to be defined as abstract, because the function <code class="docutils literal notranslate">utterance()</code> is declared, but no implementation was provided (no implementation body <code class="docutils literal notranslate">{ }</code> was given). <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKYWJzdHJhY3QgY29udHJhY3QgRmVsaW5lIHsKICAgIGZ1bmN0aW9uIHV0dGVyYW5jZSgpIHB1YmxpYyB2aXJ0dWFsIHJldHVybnMgKGJ5dGVzMzIpOwp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; abstract contract Feline { function utterance() public virtual returns (bytes32); } </pre></div> </div> Such abstract contracts can not be instantiated directly. This is also true, if an abstract contract itself does implement all defined functions. The usage of an abstract contract as a base class is shown in the following example: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjAgPDAuOS4wOwoKYWJzdHJhY3QgY29udHJhY3QgRmVsaW5lIHsKICAgIGZ1bmN0aW9uIHV0dGVyYW5jZSgpIHB1YmxpYyBwdXJlIHZpcnR1YWwgcmV0dXJucyAoYnl0ZXMzMik7Cn0KCmNvbnRyYWN0IENhdCBpcyBGZWxpbmUgewogICAgZnVuY3Rpb24gdXR0ZXJhbmNlKCkgcHVibGljIHB1cmUgb3ZlcnJpZGUgcmV0dXJucyAoYnl0ZXMzMikgeyByZXR1cm4gIm1pYW93IjsgfQp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; abstract contract Feline { function utterance() public pure virtual returns (bytes32); } contract Cat is Feline { function utterance() public pure override returns (bytes32) { return "miaow"; } } </pre></div> </div> If a contract inherits from an abstract contract and does not implement all non-implemented functions by overriding, it needs to be marked as abstract as well. Note that a function without implementation is different from a <a class="reference internal" href="types.html#function-types">Function Type</a> even though their syntax looks very similar. Example of function without implementation (a function declaration): <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=ZnVuY3Rpb24gZm9vKGFkZHJlc3MpIGV4dGVybmFsIHJldHVybnMgKGFkZHJlc3MpOw==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>function foo(address) external returns (address); </pre></div> </div> Example of a declaration of a variable whose type is a function type: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=ZnVuY3Rpb24oYWRkcmVzcykgZXh0ZXJuYWwgcmV0dXJucyAoYWRkcmVzcykgZm9vOw==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>function(address) external returns (address) foo; </pre></div> </div> Abstract contracts decouple the definition of a contract from its implementation providing better extensibility and self-documentation and facilitating patterns like the <a class="reference external" href="https://en.wikipedia.org/wiki/Template_method_pattern">Template method</a> and removing code duplication. Abstract contracts are useful in the same way that defining methods in an interface is useful. It is a way for the designer of the abstract contract to say “any child of mine must implement this method”. <div class="admonition note"> Note Abstract contracts cannot override an implemented virtual function with an unimplemented one. </div> </section> <section id="interfaces"> <h2>Interfaces<a class="headerlink" href="#interfaces" title="Permalink to this heading"></a></h2> Interfaces are similar to abstract contracts, but they cannot have any functions implemented. There are further restrictions: <ul class="simple"> <li>They cannot inherit from other contracts, but they can inherit from other interfaces.</li> <li>All declared functions must be external in the interface, even if they are public in the contract.</li> <li>They cannot declare a constructor.</li> <li>They cannot declare state variables.</li> <li>They cannot declare modifiers.</li> </ul> Some of these restrictions might be lifted in the future. Interfaces are basically limited to what the Contract ABI can represent, and the conversion between the ABI and an interface should be possible without any information loss. Interfaces are denoted by their own keyword: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjIgPDAuOS4wOwoKaW50ZXJmYWNlIFRva2VuIHsKICAgIGVudW0gVG9rZW5UeXBlIHsgRnVuZ2libGUsIE5vbkZ1bmdpYmxlIH0KICAgIHN0cnVjdCBDb2luIHsgc3RyaW5nIG9idmVyc2U7IHN0cmluZyByZXZlcnNlOyB9CiAgICBmdW5jdGlvbiB0cmFuc2ZlcihhZGRyZXNzIHJlY2lwaWVudCwgdWludCBhbW91bnQpIGV4dGVybmFsOwp9" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.2 <0.9.0; interface Token { enum TokenType { Fungible, NonFungible } struct Coin { string obverse; string reverse; } function transfer(address recipient, uint amount) external; } </pre></div> </div> Contracts can inherit interfaces as they would inherit other contracts. All functions declared in interfaces are implicitly <code class="docutils literal notranslate">virtual</code> and any functions that override them do not need the <code class="docutils literal notranslate">override</code> keyword. This does not automatically mean that an overriding function can be overridden again - this is only possible if the overriding function is marked <code class="docutils literal notranslate">virtual</code>. Interfaces can inherit from other interfaces. This has the same rules as normal inheritance. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC42LjIgPDAuOS4wOwoKaW50ZXJmYWNlIFBhcmVudEEgewogICAgZnVuY3Rpb24gdGVzdCgpIGV4dGVybmFsIHJldHVybnMgKHVpbnQyNTYpOwp9CgppbnRlcmZhY2UgUGFyZW50QiB7CiAgICBmdW5jdGlvbiB0ZXN0KCkgZXh0ZXJuYWwgcmV0dXJucyAodWludDI1Nik7Cn0KCmludGVyZmFjZSBTdWJJbnRlcmZhY2UgaXMgUGFyZW50QSwgUGFyZW50QiB7CiAgICAvLyBNdXN0IHJlZGVmaW5lIHRlc3QgaW4gb3JkZXIgdG8gYXNzZXJ0IHRoYXQgdGhlIHBhcmVudAogICAgLy8gbWVhbmluZ3MgYXJlIGNvbXBhdGlibGUuCiAgICBmdW5jdGlvbiB0ZXN0KCkgZXh0ZXJuYWwgb3ZlcnJpZGUoUGFyZW50QSwgUGFyZW50QikgcmV0dXJucyAodWludDI1Nik7Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.2 <0.9.0; interface ParentA { function test() external returns (uint256); } interface ParentB { function test() external returns (uint256); } interface SubInterface is ParentA, ParentB { // Must redefine test in order to assert that the parent // meanings are compatible. function test() external override(ParentA, ParentB) returns (uint256); } </pre></div> </div> Types defined inside interfaces and other contract-like structures can be accessed from other contracts: <code class="docutils literal notranslate">Token.TokenType</code> or <code class="docutils literal notranslate">Token.Coin</code>. <div class="admonition warning"> Warning Interfaces have supported <code class="docutils literal notranslate">enum</code> types since <a class="reference internal" href="050-breaking-changes.html">Solidity version 0.5.0</a>, make sure the pragma version specifies this version as a minimum. </div> </section> <section id="libraries"> <h2>Libraries<a class="headerlink" href="#libraries" title="Permalink to this heading"></a></h2> Libraries are similar to contracts, but their purpose is that they are deployed only once at a specific address and their code is reused using the <code class="docutils literal notranslate">DELEGATECALL</code> (<code class="docutils literal notranslate">CALLCODE</code> until Homestead) feature of the EVM. This means that if library functions are called, their code is executed in the context of the calling contract, i.e. <code class="docutils literal notranslate">this</code> points to the calling contract, and especially the storage from the calling contract can be accessed. As a library is an isolated piece of source code, it can only access state variables of the calling contract if they are explicitly supplied (it would have no way to name them, otherwise). Library functions can only be called directly (i.e. without the use of <code class="docutils literal notranslate">DELEGATECALL</code>) if they do not modify the state (i.e. if they are <code class="docutils literal notranslate">view</code> or <code class="docutils literal notranslate">pure</code> functions), because libraries are assumed to be stateless. In particular, it is not possible to destroy a library. <div class="admonition note"> Note Until version 0.4.20, it was possible to destroy libraries by circumventing Solidity’s type system. Starting from that version, libraries contain a <a class="reference internal" href="#call-protection">mechanism</a> that disallows state-modifying functions to be called directly (i.e. without <code class="docutils literal notranslate">DELEGATECALL</code>). </div> Libraries can be seen as implicit base contracts of the contracts that use them. They will not be explicitly visible in the inheritance hierarchy, but calls to library functions look just like calls to functions of explicit base contracts (using qualified access like <code class="docutils literal notranslate">L.f()</code>). Of course, calls to internal functions use the internal calling convention, which means that all internal types can be passed and types <a class="reference internal" href="types.html#data-location">stored in memory</a> will be passed by reference and not copied. To realize this in the EVM, the code of internal library functions that are called from a contract and all functions called from therein will at compile time be included in the calling contract, and a regular <code class="docutils literal notranslate">JUMP</code> call will be used instead of a <code class="docutils literal notranslate">DELEGATECALL</code>. <div class="admonition note"> Note The inheritance analogy breaks down when it comes to public functions. Calling a public library function with <code class="docutils literal notranslate">L.f()</code> results in an external call (<code class="docutils literal notranslate">DELEGATECALL</code> to be precise). In contrast, <code class="docutils literal notranslate">A.f()</code> is an internal call when <code class="docutils literal notranslate">A</code> is a base contract of the current contract. </div> The following example illustrates how to use libraries (but using a manual method, be sure to check out <a class="reference internal" href="#using-for">using for</a> for a more advanced example to implement a set). <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=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" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.6.0 <0.9.0; // We define a new struct datatype that will be used to // hold its data in the calling contract. struct Data { mapping(uint => bool) flags; } library Set { // Note that the first parameter is of type "storage // reference" and thus only its storage address and not // its contents is passed as part of the call. This is a // special feature of library functions. It is idiomatic // to call the first parameter `self`, if the function can // be seen as a method of that object. function insert(Data storage self, uint value) public returns (bool) { if (self.flags[value]) return false; // already there self.flags[value] = true; return true; } function remove(Data storage self, uint value) public returns (bool) { if (!self.flags[value]) return false; // not there self.flags[value] = false; return true; } function contains(Data storage self, uint value) public view returns (bool) { return self.flags[value]; } } contract C { Data knownValues; function register(uint value) public { // The library functions can be called without a // specific instance of the library, since the // "instance" will be the current contract. require(Set.insert(knownValues, value)); } // In this contract, we can also directly access knownValues.flags, if we want. } </pre></div> </div> Of course, you do not have to follow this way to use libraries: they can also be used without defining struct data types. Functions also work without any storage reference parameters, and they can have multiple storage reference parameters and in any position. The calls to <code class="docutils literal notranslate">Set.contains</code>, <code class="docutils literal notranslate">Set.insert</code> and <code class="docutils literal notranslate">Set.remove</code> are all compiled as calls (<code class="docutils literal notranslate">DELEGATECALL</code>) to an external contract/library. If you use libraries, be aware that an actual external function call is performed. <code class="docutils literal notranslate">msg.sender</code>, <code class="docutils literal notranslate">msg.value</code> and <code class="docutils literal notranslate">this</code> will retain their values in this call, though (prior to Homestead, because of the use of <code class="docutils literal notranslate">CALLCODE</code>, <code class="docutils literal notranslate">msg.sender</code> and <code class="docutils literal notranslate">msg.value</code> changed, though). The following example shows how to use <a class="reference internal" href="types.html#data-location">types stored in memory</a> and internal functions in libraries in order to implement custom types without the overhead of external function calls: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=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" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.0; struct bigint { uint[] limbs; } library BigInt { function fromUint(uint x) internal pure returns (bigint memory r) { r.limbs = new uint[](1); r.limbs[0] = x; } function add(bigint memory a, bigint memory b) internal pure returns (bigint memory r) { r.limbs = new uint[](max(a.limbs.length, b.limbs.length)); uint carry = 0; for (uint i = 0; i < r.limbs.length; ++i) { uint limbA = limb(a, i); uint limbB = limb(b, i); unchecked { r.limbs[i] = limbA + limbB + carry; if (limbA + limbB < limbA || (limbA + limbB == type(uint).max && carry > 0)) carry = 1; else carry = 0; } } if (carry > 0) { // too bad, we have to add a limb uint[] memory newLimbs = new uint[](r.limbs.length + 1); uint i; for (i = 0; i < r.limbs.length; ++i) newLimbs[i] = r.limbs[i]; newLimbs[i] = carry; r.limbs = newLimbs; } } function limb(bigint memory a, uint index) internal pure returns (uint) { return index < a.limbs.length ? a.limbs[index] : 0; } function max(uint a, uint b) private pure returns (uint) { return a > b ? a : b; } } contract C { using BigInt for bigint; function f() public pure { bigint memory x = BigInt.fromUint(7); bigint memory y = BigInt.fromUint(type(uint).max); bigint memory z = x.add(y); assert(z.limb(1) > 0); } } </pre></div> </div> It is possible to obtain the address of a library by converting the library type to the <code class="docutils literal notranslate">address</code> type, i.e. using <code class="docutils literal notranslate">address(LibraryName)</code>. As the compiler does not know the address where the library will be deployed, the compiled hex code will contain placeholders of the form <code class="docutils literal notranslate">__$30bbc0abd4d6364515865950d3e0d10953$__</code> <a class="reference external" href="https://docs.soliditylang.org/en/v0.4.26/contracts.html#libraries">(format was different <v0.5.0)</a>. The placeholder is a 34 character prefix of the hex encoding of the keccak256 hash of the fully qualified library name, which would be for example <code class="docutils literal notranslate">libraries/bigint.sol:BigInt</code> if the library was stored in a file called <code class="docutils literal notranslate">bigint.sol</code> in a <code class="docutils literal notranslate">libraries/</code> directory. Such bytecode is incomplete and should not be deployed. Placeholders need to be replaced with actual addresses. You can do that by either passing them to the compiler when the library is being compiled or by using the linker to update an already compiled binary. See <a class="reference internal" href="using-the-compiler.html#library-linking">Library Linking</a> for information on how to use the commandline compiler for linking. In comparison to contracts, libraries are restricted in the following ways: <ul class="simple"> <li>they cannot have state variables</li> <li>they cannot inherit nor be inherited</li> <li>they cannot receive Ether</li> <li>they cannot be destroyed</li> </ul> (These might be lifted at a later point.) <section id="function-signatures-and-selectors-in-libraries"> <h3>Function Signatures and Selectors in Libraries<a class="headerlink" href="#function-signatures-and-selectors-in-libraries" title="Permalink to this heading"></a></h3> While external calls to public or external library functions are possible, the calling convention for such calls is considered to be internal to Solidity and not the same as specified for the regular <a class="reference internal" href="abi-spec.html#abi">contract ABI</a>. External library functions support more argument types than external contract functions, for example recursive structs and storage pointers. For that reason, the function signatures used to compute the 4-byte selector are computed following an internal naming schema and arguments of types not supported in the contract ABI use an internal encoding. The following identifiers are used for the types in the signatures: <ul class="simple"> <li>Value types, non-storage <code class="docutils literal notranslate">string</code> and non-storage <code class="docutils literal notranslate">bytes</code> use the same identifiers as in the contract ABI.</li> <li>Non-storage array types follow the same convention as in the contract ABI, i.e. <code class="docutils literal notranslate"><type>[]</code> for dynamic arrays and <code class="docutils literal notranslate"><type>[M]</code> for fixed-size arrays of <code class="docutils literal notranslate">M</code> elements.</li> <li>Non-storage structs are referred to by their fully qualified name, i.e. <code class="docutils literal notranslate">C.S</code> for <code class="docutils literal notranslate">contract C { struct S { ... } }</code>.</li> <li>Storage pointer mappings use <code class="docutils literal notranslate">mapping(<keyType> => <valueType>) storage</code> where <code class="docutils literal notranslate"><keyType></code> and <code class="docutils literal notranslate"><valueType></code> are the identifiers for the key and value types of the mapping, respectively.</li> <li>Other storage pointer types use the type identifier of their corresponding non-storage type, but append a single space followed by <code class="docutils literal notranslate">storage</code> to it.</li> </ul> The argument encoding is the same as for the regular contract ABI, except for storage pointers, which are encoded as a <code class="docutils literal notranslate">uint256</code> value referring to the storage slot to which they point. Similarly to the contract ABI, the selector consists of the first four bytes of the Keccak256-hash of the signature. Its value can be obtained from Solidity using the <code class="docutils literal notranslate">.selector</code> member as follows: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5ID49MC41LjE0IDwwLjkuMDsKCmxpYnJhcnkgTCB7CiAgICBmdW5jdGlvbiBmKHVpbnQyNTYpIGV4dGVybmFsIHt9Cn0KCmNvbnRyYWN0IEMgewogICAgZnVuY3Rpb24gZygpIHB1YmxpYyBwdXJlIHJldHVybnMgKGJ5dGVzNCkgewogICAgICAgIHJldHVybiBMLmYuc2VsZWN0b3I7CiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.5.14 <0.9.0; library L { function f(uint256) external {} } contract C { function g() public pure returns (bytes4) { return L.f.selector; } } </pre></div> </div> </section> <section id="call-protection-for-libraries"> <h3>Call Protection For Libraries<a class="headerlink" href="#call-protection-for-libraries" title="Permalink to this heading"></a></h3> As mentioned in the introduction, if a library’s code is executed using a <code class="docutils literal notranslate">CALL</code> instead of a <code class="docutils literal notranslate">DELEGATECALL</code> or <code class="docutils literal notranslate">CALLCODE</code>, it will revert unless a <code class="docutils literal notranslate">view</code> or <code class="docutils literal notranslate">pure</code> function is called. The EVM does not provide a direct way for a contract to detect whether it was called using <code class="docutils literal notranslate">CALL</code> or not, but a contract can use the <code class="docutils literal notranslate">ADDRESS</code> opcode to find out “where” it is currently running. The generated code compares this address to the address used at construction time to determine the mode of calling. More specifically, the runtime code of a library always starts with a push instruction, which is a zero of 20 bytes at compilation time. When the deploy code runs, this constant is replaced in memory by the current address and this modified code is stored in the contract. At runtime, this causes the deploy time address to be the first constant to be pushed onto the stack and the dispatcher code compares the current address against this constant for any non-view and non-pure function. This means that the actual code stored on chain for a library is different from the code reported by the compiler as <code class="docutils literal notranslate">deployedBytecode</code>. </section> </section> <section id="using-for"> <h2>Using For<a class="headerlink" href="#using-for" title="Permalink to this heading"></a></h2> The directive <code class="docutils literal notranslate">using A for B</code> can be used to attach functions (<code class="docutils literal notranslate">A</code>) as operators to user-defined value types or as member functions to any type (<code class="docutils literal notranslate">B</code>). The member functions receive the object they are called on as their first parameter (like the <code class="docutils literal notranslate">self</code> variable in Python). The operator functions receive operands as parameters. It is valid either at file level or inside a contract, at contract level. The first part, <code class="docutils literal notranslate">A</code>, can be one of: <ul class="simple"> <li>A list of functions, optionally with an operator name assigned (e.g. <code class="docutils literal notranslate">using {f, g as +, h, L.t} for uint</code>). If no operator is specified, the function can be either a library function or a free function and is attached to the type as a member function. Otherwise it must be a free function and it becomes the definition of that operator on the type.</li> <li>The name of a library (e.g. <code class="docutils literal notranslate">using L for uint</code>) - all non-private functions of the library are attached to the type as member functions</li> </ul> At file level, the second part, <code class="docutils literal notranslate">B</code>, has to be an explicit type (without data location specifier). Inside contracts, you can also use <code class="docutils literal notranslate">*</code> in place of the type (e.g. <code class="docutils literal notranslate">using L for *;</code>), which has the effect that all functions of the library <code class="docutils literal notranslate">L</code> are attached to all types. If you specify a library, all non-private functions in the library get attached, even those where the type of the first parameter does not match the type of the object. The type is checked at the point the function is called and function overload resolution is performed. If you use a list of functions (e.g. <code class="docutils literal notranslate">using {f, g, h, L.t} for uint</code>), then the type (<code class="docutils literal notranslate">uint</code>) has to be implicitly convertible to the first parameter of each of these functions. This check is performed even if none of these functions are called. Note that private library functions can only be specified when <code class="docutils literal notranslate">using for</code> is inside a library. If you define an operator (e.g. <code class="docutils literal notranslate">using {f as +} for T</code>), then the type (<code class="docutils literal notranslate">T</code>) must be a <a class="reference internal" href="types.html#user-defined-value-types">user-defined value type</a> and the definition must be a <code class="docutils literal notranslate">pure</code> function. Operator definitions must be global. The following operators can be defined this way: <table class="docutils align-default"> <thead> <tr class="row-odd"><th class="head">Category</th> <th class="head">Operator</th> <th class="head">Possible signatures</th> </tr> </thead> <tbody> <tr class="row-even"><td rowspan="4">Bitwise</td> <td><code class="docutils literal notranslate">&</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate">|</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-even"><td><code class="docutils literal notranslate">^</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate">~</code></td> <td><code class="docutils literal notranslate">function (T) pure returns (T)</code></td> </tr> <tr class="row-even"><td rowspan="6">Arithmetic</td> <td><code class="docutils literal notranslate">+</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-odd"><td rowspan="2"><code class="docutils literal notranslate">-</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-even"><td><code class="docutils literal notranslate">function (T) pure returns (T)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate">*</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-even"><td><code class="docutils literal notranslate">/</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate">%</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (T)</code></td> </tr> <tr class="row-even"><td rowspan="6">Comparison</td> <td><code class="docutils literal notranslate">==</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (bool)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate">!=</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (bool)</code></td> </tr> <tr class="row-even"><td><code class="docutils literal notranslate"><</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (bool)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate"><=</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (bool)</code></td> </tr> <tr class="row-even"><td><code class="docutils literal notranslate">></code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (bool)</code></td> </tr> <tr class="row-odd"><td><code class="docutils literal notranslate">>=</code></td> <td><code class="docutils literal notranslate">function (T, T) pure returns (bool)</code></td> </tr> </tbody> </table> Note that unary and binary <code class="docutils literal notranslate">-</code> need separate definitions. The compiler will choose the right definition based on how the operator is invoked. The <code class="docutils literal notranslate">using A for B;</code> directive is active only within the current scope (either the contract or the current module/source unit), including within all of its functions, and has no effect outside of the contract or module in which it is used. When the directive is used at file level and applied to a user-defined type which was defined at file level in the same file, the word <code class="docutils literal notranslate">global</code> can be added at the end. This will have the effect that the functions and operators are attached to the type everywhere the type is available (including other files), not only in the scope of the using statement. Let us rewrite the set example from the <a class="reference internal" href="#libraries">Libraries</a> section in this way, using file-level functions instead of library functions. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMTM7CgpzdHJ1Y3QgRGF0YSB7IG1hcHBpbmcodWludCA9PiBib29sKSBmbGFnczsgfQovLyBOb3cgd2UgYXR0YWNoIGZ1bmN0aW9ucyB0byB0aGUgdHlwZS4KLy8gVGhlIGF0dGFjaGVkIGZ1bmN0aW9ucyBjYW4gYmUgdXNlZCB0aHJvdWdob3V0IHRoZSByZXN0IG9mIHRoZSBtb2R1bGUuCi8vIElmIHlvdSBpbXBvcnQgdGhlIG1vZHVsZSwgeW91IGhhdmUgdG8KLy8gcmVwZWF0IHRoZSB1c2luZyBkaXJlY3RpdmUgdGhlcmUsIGZvciBleGFtcGxlIGFzCi8vICAgaW1wb3J0ICJmbGFncy5zb2wiIGFzIEZsYWdzOwovLyAgIHVzaW5nIHtGbGFncy5pbnNlcnQsIEZsYWdzLnJlbW92ZSwgRmxhZ3MuY29udGFpbnN9Ci8vICAgICBmb3IgRmxhZ3MuRGF0YTsKdXNpbmcge2luc2VydCwgcmVtb3ZlLCBjb250YWluc30gZm9yIERhdGE7CgpmdW5jdGlvbiBpbnNlcnQoRGF0YSBzdG9yYWdlIHNlbGYsIHVpbnQgdmFsdWUpCiAgICByZXR1cm5zIChib29sKQp7CiAgICBpZiAoc2VsZi5mbGFnc1t2YWx1ZV0pCiAgICAgICAgcmV0dXJuIGZhbHNlOyAvLyBhbHJlYWR5IHRoZXJlCiAgICBzZWxmLmZsYWdzW3ZhbHVlXSA9IHRydWU7CiAgICByZXR1cm4gdHJ1ZTsKfQoKZnVuY3Rpb24gcmVtb3ZlKERhdGEgc3RvcmFnZSBzZWxmLCB1aW50IHZhbHVlKQogICAgcmV0dXJucyAoYm9vbCkKewogICAgaWYgKCFzZWxmLmZsYWdzW3ZhbHVlXSkKICAgICAgICByZXR1cm4gZmFsc2U7IC8vIG5vdCB0aGVyZQogICAgc2VsZi5mbGFnc1t2YWx1ZV0gPSBmYWxzZTsKICAgIHJldHVybiB0cnVlOwp9CgpmdW5jdGlvbiBjb250YWlucyhEYXRhIHN0b3JhZ2Ugc2VsZiwgdWludCB2YWx1ZSkKICAgIHZpZXcKICAgIHJldHVybnMgKGJvb2wpCnsKICAgIHJldHVybiBzZWxmLmZsYWdzW3ZhbHVlXTsKfQoKCmNvbnRyYWN0IEMgewogICAgRGF0YSBrbm93blZhbHVlczsKCiAgICBmdW5jdGlvbiByZWdpc3Rlcih1aW50IHZhbHVlKSBwdWJsaWMgewogICAgICAgIC8vIEhlcmUsIGFsbCB2YXJpYWJsZXMgb2YgdHlwZSBEYXRhIGhhdmUKICAgICAgICAvLyBjb3JyZXNwb25kaW5nIG1lbWJlciBmdW5jdGlvbnMuCiAgICAgICAgLy8gVGhlIGZvbGxvd2luZyBmdW5jdGlvbiBjYWxsIGlzIGlkZW50aWNhbCB0bwogICAgICAgIC8vIGBTZXQuaW5zZXJ0KGtub3duVmFsdWVzLCB2YWx1ZSlgCiAgICAgICAgcmVxdWlyZShrbm93blZhbHVlcy5pbnNlcnQodmFsdWUpKTsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.13; struct Data { mapping(uint => bool) flags; } // Now we attach functions to the type. // The attached functions can be used throughout the rest of the module. // If you import the module, you have to // repeat the using directive there, for example as // import "flags.sol" as Flags; // using {Flags.insert, Flags.remove, Flags.contains} // for Flags.Data; using {insert, remove, contains} for Data; function insert(Data storage self, uint value) returns (bool) { if (self.flags[value]) return false; // already there self.flags[value] = true; return true; } function remove(Data storage self, uint value) returns (bool) { if (!self.flags[value]) return false; // not there self.flags[value] = false; return true; } function contains(Data storage self, uint value) view returns (bool) { return self.flags[value]; } contract C { Data knownValues; function register(uint value) public { // Here, all variables of type Data have // corresponding member functions. // The following function call is identical to // `Set.insert(knownValues, value)` require(knownValues.insert(value)); } } </pre></div> </div> It is also possible to extend built-in types in that way. In this example, we will use a library. <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMTM7CgpsaWJyYXJ5IFNlYXJjaCB7CiAgICBmdW5jdGlvbiBpbmRleE9mKHVpbnRbXSBzdG9yYWdlIHNlbGYsIHVpbnQgdmFsdWUpCiAgICAgICAgcHVibGljCiAgICAgICAgdmlldwogICAgICAgIHJldHVybnMgKHVpbnQpCiAgICB7CiAgICAgICAgZm9yICh1aW50IGkgPSAwOyBpIDwgc2VsZi5sZW5ndGg7IGkrKykKICAgICAgICAgICAgaWYgKHNlbGZbaV0gPT0gdmFsdWUpIHJldHVybiBpOwogICAgICAgIHJldHVybiB0eXBlKHVpbnQpLm1heDsKICAgIH0KfQp1c2luZyBTZWFyY2ggZm9yIHVpbnRbXTsKCmNvbnRyYWN0IEMgewogICAgdWludFtdIGRhdGE7CgogICAgZnVuY3Rpb24gYXBwZW5kKHVpbnQgdmFsdWUpIHB1YmxpYyB7CiAgICAgICAgZGF0YS5wdXNoKHZhbHVlKTsKICAgIH0KCiAgICBmdW5jdGlvbiByZXBsYWNlKHVpbnQgZnJvbSwgdWludCB0bykgcHVibGljIHsKICAgICAgICAvLyBUaGlzIHBlcmZvcm1zIHRoZSBsaWJyYXJ5IGZ1bmN0aW9uIGNhbGwKICAgICAgICB1aW50IGluZGV4ID0gZGF0YS5pbmRleE9mKGZyb20pOwogICAgICAgIGlmIChpbmRleCA9PSB0eXBlKHVpbnQpLm1heCkKICAgICAgICAgICAgZGF0YS5wdXNoKHRvKTsKICAgICAgICBlbHNlCiAgICAgICAgICAgIGRhdGFbaW5kZXhdID0gdG87CiAgICB9Cn0=" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.13; library Search { function indexOf(uint[] storage self, uint value) public view returns (uint) { for (uint i = 0; i < self.length; i++) if (self[i] == value) return i; return type(uint).max; } } using Search for uint[]; contract C { uint[] data; function append(uint value) public { data.push(value); } function replace(uint from, uint to) public { // This performs the library function call uint index = data.indexOf(from); if (index == type(uint).max) data.push(to); else data[index] = to; } } </pre></div> </div> Note that all external library calls are actual EVM function calls. This means that if you pass memory or value types, a copy will be performed, even in case of the <code class="docutils literal notranslate">self</code> variable. The only situation where no copy will be performed is when storage reference variables are used or when internal library functions are called. Another example shows how to define a custom operator for a user-defined type: <a class="remix-link reference external" href="https://remix.ethereum.org/?#language=solidity&version=0.8.29&code=Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0zLjAKcHJhZ21hIHNvbGlkaXR5IF4wLjguMTk7Cgp0eXBlIFVGaXhlZDE2eDIgaXMgdWludDE2OwoKdXNpbmcgewogICAgYWRkIGFzICssCiAgICBkaXYgYXMgLwp9IGZvciBVRml4ZWQxNngyIGdsb2JhbDsKCnVpbnQzMiBjb25zdGFudCBTQ0FMRSA9IDEwMDsKCmZ1bmN0aW9uIGFkZChVRml4ZWQxNngyIGEsIFVGaXhlZDE2eDIgYikgcHVyZSByZXR1cm5zIChVRml4ZWQxNngyKSB7CiAgICByZXR1cm4gVUZpeGVkMTZ4Mi53cmFwKFVGaXhlZDE2eDIudW53cmFwKGEpICsgVUZpeGVkMTZ4Mi51bndyYXAoYikpOwp9CgpmdW5jdGlvbiBkaXYoVUZpeGVkMTZ4MiBhLCBVRml4ZWQxNngyIGIpIHB1cmUgcmV0dXJucyAoVUZpeGVkMTZ4MikgewogICAgdWludDMyIGEzMiA9IFVGaXhlZDE2eDIudW53cmFwKGEpOwogICAgdWludDMyIGIzMiA9IFVGaXhlZDE2eDIudW53cmFwKGIpOwogICAgdWludDMyIHJlc3VsdDMyID0gYTMyICogU0NBTEUgLyBiMzI7CiAgICByZXF1aXJlKHJlc3VsdDMyIDw9IHR5cGUodWludDE2KS5tYXgsICJEaXZpZGUgb3ZlcmZsb3ciKTsKICAgIHJldHVybiBVRml4ZWQxNngyLndyYXAodWludDE2KGEzMiAqIFNDQUxFIC8gYjMyKSk7Cn0KCmNvbnRyYWN0IE1hdGggewogICAgZnVuY3Rpb24gYXZnKFVGaXhlZDE2eDIgYSwgVUZpeGVkMTZ4MiBiKSBwdWJsaWMgcHVyZSByZXR1cm5zIChVRml4ZWQxNngyKSB7CiAgICAgICAgcmV0dXJuIChhICsgYikgLyBVRml4ZWQxNngyLndyYXAoMjAwKTsKICAgIH0KfQ==" target="_blank">open in Remix</a> <div class="highlight-solidity notranslate"><div class="highlight"><pre>// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.19; type UFixed16x2 is uint16; using { add as +, div as / } for UFixed16x2 global; uint32 constant SCALE = 100; function add(UFixed16x2 a, UFixed16x2 b) pure returns (UFixed16x2) { return UFixed16x2.wrap(UFixed16x2.unwrap(a) + UFixed16x2.unwrap(b)); } function div(UFixed16x2 a, UFixed16x2 b) pure returns (UFixed16x2) { uint32 a32 = UFixed16x2.unwrap(a); uint32 b32 = UFixed16x2.unwrap(b); uint32 result32 = a32 * SCALE / b32; require(result32 <= type(uint16).max, "Divide overflow"); return UFixed16x2.wrap(uint16(a32 * SCALE / b32)); } contract Math { function avg(UFixed16x2 a, UFixed16x2 b) public pure returns (UFixed16x2) { return (a + b) / UFixed16x2.wrap(200); } } </pre></div> </div> </section> </section> </div> </div> <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer"> <a href="control-structures.html" class="btn btn-neutral float-left" title="Expressions and Control Structures" accesskey="p" rel="prev"> Previous</a> <a href="assembly.html" class="btn btn-neutral float-right" title="Inline Assembly" accesskey="n" rel="next">Next </a> </div> <hr/> <div role="contentinfo"> © Copyright 2016-2024, The Solidity Authors. </div> <a href="credits-and-attribution.html">Credits and attribution</a>. </footer> </div> </div> </section> </div> <script> jQuery(function () { SphinxRtdTheme.Navigation.enable(true); }); </script> </body> </html>