Upcoming Changes to Solidity and How They Function
GUARD FUNCTIONS in Solidity : Revert(), Assert(), and Require() , and the New REVERT Opcode in the EVM.
The release of Solidity version 0.4.10 introduced the functions assert(), require()and revert() . Confusion has reigned ever since.
The assert() and require() “guard” functions improve the readability of contract code, but differentiating between them can be quite confounding.
In this article, I’ll:
explain the problem these functions solve.
discuss how the Solidity compiler handles the new assert(), require()and revert()functions
Give some rules of thumb for deciding how and when to use each one.
For convenience, I’ve created a simple contract using each of these features which you can test out in remix here.
If you really just want a TLDR version, this answer on the ethereum stackexchange should suffice.
Patterns for error handling in Solidity
re: obsolete keyword “Throw”
Supplanted by new functions assert(), require(), and revert()
These provide the same functionality, with a much cleaner syntax.
Illustration: The old throw pattern way:
throw and then if …
Let’s say your contract has a few special functions that are designed to be callable only by a particular address. Let’s say the address is designated as owner.
Prior to Solidity 0.4.10 (and for a while thereafter), the following was a common pattern for enforcing permissions:
contract HasAnOwner { address owner;
function useSuperPowers(){ if (msg.sender != owner) { throw; } // do something only the owner should be allowed to do } }
If the useSuperPowers() function is called by anyone other than owner, the function will throw. The result is that it would thereby return an error:invalid opcode , undo all state changes, and use up all remaining gas (see this article for more on gas and fees in ethereum).
Happily, the throw keyword is now being deprecated, and eventually will be removed altogether. Fortunately, the new functions assert(), require(), and revert() provide the same functionality, with a much cleaner syntax.
Life after “throw”
Let’s look at the new way to update that if .. throw pattern with our new guard functions.
The line:
if(msg.sender != owner) { throw; }
succinctly substitutes for all the following:
if(msg.sender != owner) { revert(); }
assert(msg.sender == owner);
require(msg.sender == owner);
Note that in the assert() and require() examples, the conditional statement is an inversion of the if block’s condition, switching the comparison operator !=to ==.
Differentiating between assert() and require()
First, to help separate these ‘guard’ functions in your mind, imagine assert()as an overly assertive bully, who steals all your gas.Then imagine require()as a polite managerial type, who calls out your errors, but is more forgiving.
With that mnemonic handy, what’s the real difference between these two functions?
Prior to the Byzantium network upgrade, require() and assert() actually behave identically, but their bytecode output is slightly different.
assert() uses the 0xfe opcode to cause an error condition
require() uses the 0xfd opcode to cause an error condition
If you look up either of those opcodes in the yellow paper, you won’t find them. This is why you see the invalid opcode error, because there’s no specification for how a client should handle them.
Many contracts have been deployed since version 0.4.10, which include a new opcode lying dormant, until it’s no longer invalid. At the appointed time, it will wake up, and become REVERT!
Note: throw andrevert() also use 0xfd. Prior to 0.4.10. throw used 0xfe.
What the REVERT opcode will do
REVERT will still undo all state changes, but it will be handled differently than an “invalid opcode” in two ways:
It will allow you to return a value.
It will refund any remaining gas to the caller.
1. It will allow you to return a value
Most smart contract developers are quite familiar with the notoriously unhelpful invalid opcode error. Fortunately, we’ll soon be able to return an error message, or a number corresponding to an error type.
That will look something like this:
revert(‘Something bad happened’);
or
require(condition, ‘Something bad happened’);
Note: solidity doesn’t support this return value argument yet, but you can watch this issue for that update.
2. Refund the remaining gas to the caller
Currently, when your contract throws it uses up any remaining gas. This can result in a very generous donation to miners, and often ends up costing users a lot of money.
Once REVERT is implemented in the EVM, it will be plain old bad manners not to use it to refund the excess gas.
Choosing between revert(), assert() and require()
So, ifrevert() and require() both refund any left over gas, AND allow you to return a value, why would want to burn up gas using assert()?
The difference lies in the bytecode output, and for this I’ll quote from the docs(emphasis mine):
The require function should be used to ensure valid conditions, such as inputs, or contract state variables are met, or to validate return values from calls to external contracts. If used properly, analysis tools can evaluate your contract to identify the conditions and function calls which will reach a failing assert.Properly functioning code should never reach a failing assert statement; if this happens there is a bug in your contract which you should fix.
To clarify that somewhat: it should be considered a normal and healthy occurrence for a require() statement to fail (same with revert()). When an assert() statement fails, something very wrong and unexpected has happened, and you need to fix your code.
By following this guidance, static analysis and formal verification tools will be able to examine your contracts to find and prove the conditions which could break your contract, or to prove that your contract operates as designed without flaws.
In practice, I use a few heuristics to help me decide which is appropriate.
Use require()to:
Validate user inputs ie. require(input<20);
Validate the response from an external contract ie. require(external.send(amount));
Validate state conditions prior to execution, ie. require(block.number > SOME_BLOCK_NUMBER) or require(balance[msg.sender]>=amount)
Generally, you should use require most often
Generally, it will be used towards the beginning of a function
Handle the same type of situations as require(), but with more complex logic.
If you have some complex nested if/else logic flow, you may find that it makes sense to use revert() instead of require(). Keep in mind though, complex logic is a code smell.
Prevent conditions which should never, ever be possible
Generally, you will probably use assert less often
Generally, it will be used towards the end of a function.
Basically, require() should be your go to function for checking conditions, assert() is just there to prevent anything really bad from happening, but it shouldn’t be possible for the condition to evaluate to false.
Also: “you should not use assert blindly for overflow checking but only if you think that previous checks (either using ifor require) would make an overflow impossible”. — comment from @chriseth
Conclusion
These functions are very powerful tools for your security toolbox. Knowing how and when to use them will not only help prevent vulnerabilities, but also make your code more user friendly, and future proof against upcoming changes.
Access Modifiers & Applications 1:01/7:30 On completion of this lesson, you will be able to explain usage of function modifiers, explain the use of the “require” clause for input validation, illustrate the “assert” declaration for post-condition checking, discuss “reverting” a transaction and the “reward” function. The main intent of smart contract transaction is to execute a function. However, smart contracts often require control over who or what can execute the function, at what time a function needs to be executed, and what are the preconditions to be met before getting access to the function. It’s a good habit to validate input values to the function so as to avoid unnecessary execution and waste of gas.
If there are any errors found during the input validation, these have to be handled appropriately. At the end of the function execution, you may want to assert that certain conditions have been met to ensure the integrity of the smart contract. Let’s begin with an important feature of Solidity: modifiers.They can address some of the concerns just mentioned.
Modifiers can change the behavior of a function. That’s why this feature is referred to as a modifier. It is also known as a function modifier since it is specified at the entry to a function and executed before the execution of the function begins.
You can think of a modifier as a gatekeeper protecting a function. A modifier typically checks a condition using a “require” so that if the condition failed, the transaction that called the function can be reverted. This is achieved with the “revert” function. This will completely reject the transaction and revert all its state changes. It will not be recorded on the blockchain.
Let’s understand the modifier and the require clauses using the functions in the Ballot Smart Contract. To the “register” function we’ll add a modifier “onlyBy(chairperson)”. Will do that via the following steps.
Define modifier for the clause onlyBy(chairperson). Add a special notation underscore add a semicolon to the modifier definition that includes the function.
Using the modifier clause in the function header. Step 1 is a definition of the modifier “onlyBy”,
only the chairperson who created the smart contract is authorized to register any new orders.
Step 2, shows how to make the modifier include a place holder for any function.
Step 3, use the modifier clause in the header of the function definition.
Now, let’s change the existing if statement of the Ballot smart contract such that it reverses the transaction on input validation failure. Why? Because we don’t need to waste blockchain resources for a failed transaction. Next, we’ll illustrate “assert” using a function payoff that computes and pays off bets. It is preferable that the assert not fail and that it requires checking the balance after each payoff in the above case.
We are making sure bank has a balance of $10,000 after all payoffs. Under normal circumstances, assert should not fail. This is more for handling an anomalies,flaws or malicious events. In such exceptional cases, the condition would be that the bank balance would somehow dip below the required reserves.
The following picture summarizes all the features we discussed. Modifiers and error handlers, and where they are typically used. The rules, laws, policies, and governance conditions are coded as modifiers. You can use the modifiers as gatekeepers for the functions. If your transaction to invoke the function does not meet the condition specified at the header of the function, your transaction will be reverted. It will not be recorded onto the block chain.
Modifiers can also be used to validate rules external to the function. For example, rules described at the opening of the lesson, who has access to the function, at what time, and what condition, etc.
Once the screening conditions are satisfied, input validation can be carried out inside the function using require declaration statement. In this case, also the transaction will be reverted on failed validation. This is done before the execution of the function. There may be anomalies, flaws or malicious code that could result in unexpected outcomes and create
exceptions. These can be caught, usually at the end of the function, or sometimes within the function using assert declarative statement, and the entire transaction including the function execution and the state change will be reverted.
Here is an example of an online digital media “Bazaar”.
Input condition as specified by a modifier is atLeast5Sellers. This enforces the condition that there should be atLeast5Sellers with their products before a buyer initiates a buy message through a transaction.
This is a global condition for all buyers. Therefore, it is appropriate to install it using a modifier declarative statement.
Once there are enough sellers, a buyer can buy. Inside the function, we verify if the buyer has sufficient funds to buy the specific item requested. If not, the transaction is reverted. Once the verification is satisfied, money is transferred to the seller, and item is transferred to the buyer.
We have a simple assert declaration at the end that the bought item should have been transferred. After all, it’s a digital item. This point is reached only if the item has not been transferred or could not be transferred due to exceptional circumstances. This was a simplified example of concepts learned in this lesson.
In summary, function modifiers along with state reverting functions of revert, require, and assert, collectively support and lend a robust error handling-approach for a Smart Contract.
These declarative features can be used to perform formal verification and static analysis of a Smart Contract to make sure it implements the intent of its creator.
IOUCreate an IOU form in minutes with step-by-step instructions. IOU stands for “I owe you.” Record transactions with this… Learn MoreCreate Document
Loan AgreementCreate a free Loan Agreement to enforce a promise between a lender and a borrower if one party does not hold up their end… Learn MoreCreate Document
Promissory NoteA promissory note is a written document that officially recognizes a legally binding relationship between two parties — a… Learn MoreCreate Document
Deed of TrustA Deed of Trust is a legal document that officially recognizes a legally binding relationship between three parties – the… Learn MoreCreate Document
Lease AgreementA lease agreement is a written document that officially recognizes a legally binding relationship between two parties — a… Learn MoreCreate Document
Lease AmendmentA Lease Amendment is a written document that details changes or modifications to the terms of a previously executed Lease… Learn MoreCreate Document
Lease RenewalA Lease Renewal Agreement is a written document that extends the term of an existing Lease Agreement between a landlord or… Learn MoreCreate Document
Mechanic’s LienA Mechanic’s Lien provides security to builders and artisans by detailing money owed to the contractor for either services… Learn MoreCreate Document
Mortgage DeedA Mortgage Agreement is a written document that officially recognizes a legally binding relationship between two parties -… Learn MoreCreate Document
Moving ChecklistA Moving Checklist is an important tool for effectively accounting for property and other considerations before and after… Learn MoreCreate Document
Quitclaim DeedA Quitclaim Deed is a legal document where the Grantor (or owner/seller) releases his or her ownership rights in a piece… Learn MoreCreate Document
Warranty DeedA Warranty Deed legally promises a Grantor or Seller has the right to transfer a piece of real property (i.e. land, home,… Learn MoreCreate Document
Use our attorney-drafted Lease Agreement form to finalize the renting out of your house, apartment, condo, basement or attic.Select State Select State Alabama Alaska Arizona Arkansas California Colorado Connecticut District of Columbia Delaware Florida Georgia Hawaii Idaho Illinois Indiana Iowa Kansas Kentucky Louisiana Maine Maryland Massachusetts Michigan Minnesota Mississippi Missouri Montana Nebraska Nevada New Hampshire New Jersey New Mexico New York North Carolina North Dakota Ohio Oklahoma Oregon Pennsylvania Rhode Island South Carolina South Dakota Tennessee Texas Utah Vermont Virginia Washington West Virginia Wisconsin Wyoming Create Document
Create a document in 3 easy steps
01Create DocumentSelect your State and click “Create Document”
02Answer QuestionsComplete your Document in Minutes
03Download DocumentPrint and Download Word or PDF for Free
A lease agreement is a written document that officially recognizes a legally binding relationship between two parties — a landlord and a tenant. This page covers residential agreements — click the following link if you’re looking for information about commercial lease agreements.
A landlord and a tenant shake hands after successfully negotiating an agreement.
A simple residential lease agreement in writing will identify the following basic elements:
Premises: a house, apartment, condo, basement, or attic
Landlord: the owner of the Premise, aka “Lessor”
Tenant: renter who wants to live in the Premises, aka “Lessee”
Rent: amount of money paid by the Tenant to the Landlord
Term: length of time the Tenant has the right to stay on the Premises
An example of an agreement that contains all of the necessary basic information.
The sample residential lease agreement below describes a contract between “Landlord” Keith Richards and “Tenant” Clara Trueba. She agrees to rent a two bed room, two bathroom apartment in Los Angeles for $2,000 per month for a fixed length of 12 months. The tenant agrees to pay for electricity, gas, water, cable television, and telephone, and the landlord agrees to pay for trash and sewage. This is a good example of what provisions a simple lease agreement might contain, and how one should look in its final form.Page 1 / 7Zoom 100%
As a reference, people often call this document by other names:
Rental Contract
Lease Form
Tenancy Agreement
Lease agreements are not limited to the above. It may also be used to cover these additional Premises:
If you’re looking for an alternative to leasing out your place, there is also the option of being a host on Airbnb for guests instead. However, take a look at our guide before considering such option.
3. When Do I Need One?
Why do you need a residential lease agreement?
When a formal relationship exists between two parties, the law recognizes that both the Landlord and Tenant have a special set of rights and obligations.
This document has the added advantage of laying out possible problems that might occur and then detailing possible solutions available to the Landlord and Tenant.
In contrast, an oral agreement (verbal, spoken, or word of mouth) is difficult to enforce in a court and is unlikely to accurately capture important details over time. Memories fade, people remember different things, and sometimes we understandably change our minds because circumstances change.
You may be on the fence about renting or selling your apartment or home. Read our article to help you make an informed decision: Should you Rent Or Sell Your Home?
A written version, however, serves as a constant reminder to everyone, including you and the court, about what everyone agreed to at the beginning of the relationship.
Here are a few examples of what a Landlord or Tenant may agree to in a simple lease agreement:
The Landlord promises to:
Repair and maintain the air conditioner or heater
Respect the Tenant’s privacy and not make any surprise visits or allow anyone else to use the condo (“Quiet Enjoyment”)
Provide a safe and clean home to the Tenant for the Term of the Lease
Return the Tenant’s Security Deposit (with interest if required) if the Tenant treats the Premises like their own and it is still in good condition at the end of the lease
Tell the Tenant in advance if they need to enter the Premises to fix something or show someone the property
The Tenant promises to:
Pay the Landlord on time each month on a specific day
Pay the utility company directly for light, gas, heating, and water
Live in the home only with their spouse, children, and maybe even their parents or grandparents (“immediate family”)
Not have a dog, cat, chinchilla, pork belly pig, or pet goat in the house without first asking the Landlord or paying a small fee (“Pet Policy”)
Not start an illegal business like a meth lab or human trafficking scheme (only “residential” and “lawful” purposes)
In contrast to a verbal, spoken, or oral agreement, an agreement in writing clearly spells out the detailed promises between the Landlord and Tenant and also explains what should happen if they break their promises to each other. If you’re planning on running a landlord business professionally, keep in mind that these promises carry the full weight of the law — avoid making these 7 major mistakes that could spell the end your business.
4. The Consequences of Not Having One
What happens if you do not have this document? The consequences can be severe.
This document can resolve problems in a neutral and objective manner before a simple problem becomes a more complicated problem.
Here is a chart of some of the preventable suffering a lease agreement could resolve if the Landlord and Tenant took the time to create one in writing:
Potential Problems This Document Will Solve
Landlord
Tenant
Lost rent money
Damaged or bad credit
Unpaid utility bills
Unable to find a new place
HOA fees for nuisance or eye sores
Getting sick because there is no heat
Property damage
Penalties for unpermitted use
Expensive lawyer fees
Expensive lawyer fees
Personal safety & well being
Property damage
Risk of illegal activities
Personal safety & wellbeing
Fear of Landlord
5. The Most Common Landlord-Tenant Relationships
Who needs a lease agreement?
A landlord and a tenant no longer have to be a person. In fact, a landlord or tenant could actually be an organization or company that owns an entire apartment building or just two normal people.
Possible Landlords and Tenants
An individual
Homeowners and Renters
Family members
Users of a public online search engine
i.e. PadMapper, Craigslist, Zillow, or AirBnB
Spouses
Husband and wife
Same sex marriage partners
An organization
Public housing agency
Company employer for an employee
Property managers
Tenant placement services
Partners
Legally recognized domestic partners
Boyfriend and girlfriend
Friends
Roommates
6. What Should be Included
A simple residential lease agreement should generally have at least the following:
1. Who is on the hook? (the “Parties”)
This document should definitely name the parties and where they live:
The Landlord and their current address
The Tenant and their current address
An example of where to write Tenant and Landlord names.
2. Where? (the “Premises”)
It is common sense for a Texas residential lease agreement to explicitly identify that everyone is talking about the same place — a sleek and modern studio apartment in Dallas or the attic room of a rustic home of a college town like Austin.
Our version requires you write down the exact address and type of place being rented (the “Premises”).
An example of the “Premises” section
3. For how long? (the “Term”)
A standard document should detail exactly when the lease begins and ends. By listing the date, there is a clear understanding of when the relationship and the promises start and finish.
Depending on where you live, a month to month rental agreement carries a different set of rights and obligations than a 1 year lease agreement. Nolo provides a quick low down on the difference between a rental agreement — usually for a short 30-day period that automatically renews — and a lease agreement — usually longer 6-month or 1 year plus period that ends.
Note: If the Tenant does not renew the Lease and the Landlord allows the Tenant to continue staying on the Premises after the Lease expires, states usually treat this as a month-to-month- tenancy.
An example of the “Term” section
4. For how much? (the “Rent”)
“Just pay what you think is fair,” or a number written on the back of a napkin is not an option. This document should explicitly list the monthly rental amount. If you are unsure of what the going rate is for a place, check out Zillow. You can also include the terms of whether the rent may be subjected to changes in future, using a Notice of Rent Increase.
Other details may include what happens if rent is late. Will a late payment fee or interest rate apply? For example, if the monthly rent of $500 is due on the first of the month, what happens if the rent is not paid until the 15th of the month? You can use a Late Rent Notice to ensure rent payment is made. Learn more about late rent fees from Nolo.
An example of the “Rent” and “Additional Rent” sections.
5. What about a Security Deposit?
Landlords have the right to collect a Security Deposit from their Tenants. Security Deposits are usually paid up front at the beginning of the lease. The Tenant promises that they will treat the Landlord’s home like their own. The Landlord promises that they will return the Security Deposit if the Tenant does not damage the Premises. For more information about Security Deposits, please read this Wikipedia article.
Further, some states require that Landlords return Security Deposits to their Tenants within a certain amount of time and with interest. Please check your individual state or county requirements (which the Nolo link above also covers.)
Usually, the Landlord can deduct the following amounts from the security deposit:
Unpaid rent
Cleaning costs
Key replacement costs
Cost to repair damages to Premises above ordinary wear and tear
Cost to repair damages to common areas above ordinary wear and tear
Any other amount legally allowable under the Lease
6. What other details should be included?
Here are some other useful details a written lease agreement might include:
Permissions
Access: may the Landlord come over to use the laundry machine?
Alterations: can the Tenant paint the bedroom, hang a chandelier in the living room, or install a security alarm system?
Guests: can the Tenant have a short term guest stay for two weeks?
Keys: how many copies of the key can be distributed?
Pets: can the Tenant have a pet hamster if they ask the Landlord?
Right to Entry: can the Landlord come and make repairs or show the home to a possible future Tenant? Maybe only after giving the Tenant 24 hours advance notice, unless there is an emergency water pipe burst?
Smoking Policy: can the Tenant smoke inside the Premises?
Sublet: will the Tenant be allowed to sublet the apartment to someone else without the Landlord’s permission beforehand?
Note: Subletting period must be for less than the lease term.
Water Beds: can the Tenant have a waterbed or “liquid filled furnishing” that uses 10 or more gallons of liquid?
*Other: can the Tenant start a small raised bed garden in the backyard?
Fees & Payments
Attorney Fees: who should pay the lawyer fees if there is a disagreement?
Guarantor / Co-Signer: does the Landlord require the Tenant have someone pay rent if the Tenant is unable to do so?
Insurance Liabilities: should the Tenant purchase renter’s insurance to cover the possible theft or damage of their property
Late Rent Fee: should the Tenant be responsible for paying a late fee in the event of missing a rent payment?
Appliances: will the Landlord provide a refrigerator or dishwasher?
Furniture: will the Tenant need to use the Landlord’s existing furniture?
Option to Purchase: can the Tenant buy the house at a later time?
Parking: where can the Tenant park their bicycle, Segway, car, or RV?
Advanced Warning
Asbestos Disclosure: if the apartment was built before 1981, did the Landlord tell the Tenant not to hang pictures on the walls because asbestos exposure increases if the walls and ceilings crumble?
Fire and Accidents: can the Tenant leave the Premises and end the Lease if a fire, flood, or earthquake destroys the Premises?
Lead Disclosure: if the house was built before 1978, did the Tenant receive a Lead Based Paint Disclosure Form or EPA Pamphlet?
Noise Policy: are there any quiet hours in the apartment building, condominium, or neighborhood?
Notice: when must the Landlord tell the Tenant to leave?
Property Maintenance: who is supposed to cut the grass, take out the garbage, or unclog the kitchen and bathroom drains?
Renewal: is there an option for the the Tenant to renew the Lease?
Rent Increase: how much advanced notice must the Landlord give?
Legal Speak
Default: what will happen if the Tenant does not pay rent or violates a provision of the Lease (i.e. notice of default, a chance to correct the problem, early termination of the Lease, or eviction proceedings)
Condemnation: what if the City takes the Premises for a public purpose like building a library (i.e. eminent domain)
Joint and several liability: if the rental unit is damaged by Tim the Tenant, his roommate Tina the Co-Tenant is also on the hook for the repair costs
Successors: if Larry sells the home, the buyer becomes the new Landlord
Assignment: if Larry transfers the right to collect rent to Anna, Anna is the “assign” and the Tenant must pay Anna rent
Severability: if one part of the Agreement is invalid for any reason, the rest of the Lease is still enforceable (i.e. the bad part of the Lease is “severed” or cut out from the Lease)
If you’re finding the process of managing your property more challenging than expected, consider hiring a Property Management Company to assist you. If you’re still unsure whether hiring one is right for you, read our handy article: Top 5 Reasons Landlords Should Hire a Property Management Company
7. When are you finally done?
Once you have finished negotiating and discussing the details . . .
Remember to PRINT, SIGN, and SAVE:Step 1: Print – print TWO copies for you and the other party.
Step 2: Sign – BOTH the Tenant and Landlord need to sign AND date the document
Step 3: Save – File a hard printed copy of the SIGNED document in a safe place AND scan a soft electronic copy in secure cloud storage like Google Drive or Dropbox.
Alternatively, let Legal Templates take care of this for you.Step 1: Print or PDF – generate a PDF of the document using our easy form builder that you can print or email to the other party for review as you hash out the details.
Step 2: E-Sign & Share – digitally sign your name and allow the other party to sign electronically. E-signatures are validly recognized in most states.
Step 3: Save & Store – we save a digital copy of your signed agreement and store a copy for both parties on our secure server.
Even after it has been signed, remember to do a walk through of the Premises together. Before the Tenant moves into the Premises, use a helpful checklist like the one provided by the University of Santa Cruz (UCSC) to document the current condition of the Premises.
If you’re finding the process of managing your property more challenging than expected, consider hiring a Property Management Company to assist you. If you’re still unsure whether hiring one is right for you, read our handy article: Top 5 Reasons Landlords Should Hire a Property Management Company
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.
A contract and its functions need to be called for anything to happen.
Calling a function on a different contract (instance) will perform what’s known as an EVM function call and thereby switch the context such that state variables become inaccessible.
There is no “cron” concept in Ethereum to automatically call a function at a particular event.
Creating Contracts
Contracts can be created “from outside” via Ethereum transactions
Contracts can also be created from within other Solidity contracts.
By using UI elements, IDEs, such as Remix, make the creation process seamless.
Creating contracts programmatically on Ethereum is best done using the JavaScript API web3.js. It has a function called web3.eth.Contract to facilitate contract creation.
The keyword “constructor” is used to declare a function. When that contract is created, its constructor is executed on a one time basis.
A constructor is optional. However, only one constructor is allowed, which ensures overloading is not induced.
After the constructor has executed, the final code of the contract is deployed to 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 that are called exclusively from the constructor itself.
If one contract wants to create another contract, the source code (and the binary) of the created contract have to be known to the creator. This means that cyclic creation dependencies such as cron jobs are impossible.
pragma solidity >=0.4.22 <0.7.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) public { // 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 do 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 check that. creator = TokenCreator(msg.sender); name = _name; } function changeName(bytes32 newName) public { // Only the creator can alter the name -- // the comparison is possible since contracts // are explicitly convertible to addresses. 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) publicreturns (OwnedToken tokenAddress) { // Create a new `Token` contract and return its address. // From the JavaScript side, the return type is // `address`, as this is the closest type available in // the ABI.returnnew 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) publicpurereturns (bool ok) { // Check an arbitrary condition to see if transfer should proceedreturn keccak256(abi.encodePacked(currentOwner, newOwner))[0] == 0x7f; } }
Visibility and Getters
Since Solidity knows two kinds of function calls (internal ones that do not create an actual EVM call (also called a “message call”) and external ones that do), there are four types of visibilities for functions and state variables.
Functions have to be specified as being external, public, internal or private. For state variables, external is not possible.external:External functions are part of the contract interface, which means they can be called from other contracts and via transactions. An external function f cannot be called internally (i.e. f() does not work, but this.f() works). External functions are sometimes more efficient when they receive large arrays of data.public:Public functions are part of the contract interface and can be either called internally or via messages. For public state variables, an automatic getter function (see below) is generated.internal:Those functions and state variables can only be accessed internally (i.e. from within the current contract or contracts deriving from it), without using this.private:Private functions and state variables are only visible for the contract they are defined in and not in derived contracts.
Note
Everything that is inside a contract is visible to all observers external to the blockchain. Making something private only prevents other contracts from accessing and modifying the information, but it will still be visible to the whole world outside of the blockchain.
The visibility specifier is given after the type for state variables and between parameter list and return parameter list for functions.
pragma solidity >=0.4.16 <0.7.0;
contract C {
function f(uint a) privatepurereturns (uint b) { return a + 1; }
function setData(uint a) internal { data = a; }
uint public data;
}
In the following example, D, can call c.getData() to retrieve the value of data in state storage, but is not able to call f. Contract E is derived from C and, thus, can call compute.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint private data;
function f(uint a) privatepurereturns(uint b) { return a + 1; }
function setData(uint a) public { data = a; }
function getData() publicviewreturns(uint) { return data; }
function compute(uint a, uint b) internalpurereturns (uint) { return a + b; }
}
// This will not compilecontract 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)
}
}
Getter Functions
The compiler automatically creates getter functions for all public state variables. For the contract given below, the compiler will generate a function called data that does not take any arguments and returns a uint, the value of the state variable data. State variables can be initialized when they are declared.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data = 42;
}
contract Caller {
C c = new C();
function f() publicviewreturns (uint) {
return c.data();
}
}
The getter functions have external visibility. If the symbol is accessed internally (i.e. without this.), it evaluates to a state variable. If it is accessed externally (i.e. with this.), it evaluates to a function.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data;
function x() publicreturns (uint) {
data = 3; // internal accessreturn this.data(); // external access
}
}
If you have a public 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 data(0). If you want to return an entire array in one call, then you need to write a function, for example:
pragma solidity >=0.4.0 <0.7.0;
contract arrayExample {
// public state variable
uint[] public myArray;
// Getter function generated by the compiler/* function myArray(uint i) returns (uint) { return myArray[i]; } */// function that returns entire arrayfunction getArray() returns (uint[] memory) {
return myArray;
}
}
Now you can use getArray() to retrieve the entire array, instead of myArray(i), which returns a single element per call.
It generates a function of the following form. The mapping in the struct is omitted because there is no good way to provide the key for the mapping:
function data(uint arg1, bool arg2, uint arg3) publicreturns (uint a, bytes3 b) {
a = data[arg1][arg2][arg3].a;
b = data[arg1][arg2][arg3].b;
}
Function Modifiers
Modifiers can be used to easily change the behaviour of functions. For example, they can automatically check a condition prior to executing the function. Modifiers are inheritable properties of contracts and may be overridden by derived contracts.
pragma solidity >=0.5.0 <0.7.0;
contract owned {
constructor() public { owner = 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 mortal is owned {
// This contract inherits the `onlyOwner` modifier from// `owned` and applies it to the `close` function, which// causes that calls to `close` only have an effect if// they are made by the stored owner.function close() public onlyOwner {
selfdestruct(owner);
}
}
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) public { 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() publicpayable costs(price) {
registeredAddresses[msg.sender] = true;
}
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;
}
}
Multiple modifiers are applied to a function by specifying them in a whitespace-separated list and are evaluated in the order presented.
Warning
In an earlier version of Solidity, return statements in functions having modifiers behaved differently.
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 “_” in the preceding modifier.
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).
Constant State Variables
State variables can be declared as constant. In this case, they have to be assigned from an expression which is a constant at compile time. Any expression that accesses storage, blockchain data (e.g. now, address(this).balance or block.number) or execution data (msg.value or gasleft()) 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 keccak256, sha256, ripemd160, ecrecover, addmod and mulmod are allowed (even though, with the exception of keccak256, 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.
The compiler does not reserve a storage slot for these variables, and every occurrence is replaced by the respective constant expression (which might be computed to a single value by the optimizer).
Not all types for constants are implemented at this time. The only supported types are value types and strings.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint constant x = 32**22 + 8;
string constant text = "abc";
bytes32 constant myHash = keccak256("abc");
}
Functions
Function Parameters and Return Variables
As in JavaScript, functions may take parameters as input. Unlike in JavaScript and C, functions may also return an arbitrary number of values as output.
Function Parameters
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:
pragma solidity >=0.4.16 <0.7.0;
contract Simple {
uint sum;
function taker(uint _a, uint _b) public {
sum = _a + _b;
}
}
Function parameters can be used as any other local variable and they can also be assigned to.
Note
An external function cannot accept a multi-dimensional array as an input parameter. This functionality is possible if you enable the new experimental ABIEncoderV2feature by adding pragma experimental ABIEncoderV2; to your source file.
An internal function can accept a multi-dimensional array without enabling the feature.
Return Variables
Function return variables are declared with the same syntax after the returns 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:
The names of return variables can be omitted. Return variables can be used as any other local variable and they are initialized with their default value and have that value unless explicitly set.
You can either explicitly assign to return variables and then leave the function using return;, or you can provide return values (either a single or multiple ones) directly with the return statement:
This form is equivalent to first assigning values to the return variables and then using return; to leave the function.
Note
You cannot return some types from non-internal functions, notably multi-dimensional dynamic arrays and structs. If you enable the new experimental ABIEncoderV2 feature by adding pragma experimental ABIEncoderV2; to your source file then more types are available, but mapping types are still limited to inside a single contract and you cannot transfer them.
Returning Multiple Values
When a function has multiple return types, the statement return (v0, v1, ..., vn)can be used to return multiple values. The number of components must be the same as the number of return types.
View Functions
Functions can be declared view in which case they promise not to modify the state.
Note
If the compiler’s EVM target is Byzantium or newer (default) the opcode STATICCALLis used for view functions which enforces the state to stay unmodified as part of the EVM execution. For library view functions DELEGATECALL is used, because there is no combined DELEGATECALL and STATICCALL. This means library view 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.
The following statements are considered modifying the state:
Using inline assembly that contains certain opcodes.
pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) publicviewreturns (uint) {
return a * (b + 42) + now;
}
}
Note
constant on functions used to be an alias to view, but this was dropped in version 0.5.0.
Note
Getter methods are automatically marked view.
Note
Prior to version 0.5.0, the compiler did not use the STATICCALL opcode for viewfunctions. This enabled state modifications in view functions through the use of invalid explicit type conversions. By using STATICCALL for view functions, modifications to the state are prevented on the level of the EVM.
Pure Functions
Functions can be declared pure in which case they promise not to read from or modify the state.
Note
If the compiler’s EVM target is Byzantium or newer (default) the opcode STATICCALLis used, which does not guarantee that the state is not read, but at least that it is not modified.
In addition to the list of state modifying statements explained above, the following are considered reading from the state:
Reading from state variables.
Accessing address(this).balance or <address>.balance.
Accessing any of the members of block, tx, msg (with the exception of msg.sigand msg.data).
Calling any function not marked pure.
Using inline assembly that contains certain opcodes.
pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) publicpurereturns (uint) {
return a * (b + 42);
}
}
Pure functions are able to use the revert() and require() functions to revert potential state changes when an error occurs.
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 view or pure restriction are reverted and that code has the option to catch the revert and not pass it on.
This behaviour is also in line with the STATICCALL opcode.
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 view can be enforced at the EVM level, pure can not).
Note
Prior to version 0.5.0, the compiler did not use the STATICCALL opcode for purefunctions. This enabled state modifications in pure functions through the use of invalid explicit type conversions. By using STATICCALL for pure functions, modifications to the state are prevented on the level of the EVM.
Note
Prior to version 0.4.17 the compiler did not enforce that pure is not reading the state. It is a compile-time type check, which can be circumvented 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.
Fallback Function
A contract can have exactly one unnamed function. This function cannot have arguments, cannot return anything and has to have external visibility. It is executed on a call to the contract if none of the other functions match the given function identifier (or if no data was supplied at all).
Furthermore, this function is executed whenever the contract receives plain Ether (without data). To receive Ether and add it to the total balance of the contract, the fallback function must be marked payable. If no such function exists, the contract cannot receive Ether through regular transactions and throws an exception.
In the worst case, the fallback function can only rely on 2300 gas being available (for example when send or transfer is used), leaving little room to perform other operations except basic logging. The following operations will consume more gas than the 2300 gas stipend:
Writing to storage
Creating a contract
Calling an external function which consumes a large amount of gas
Sending Ether
Like any function, the fallback function can execute complex operations as long as there is enough gas passed on to it.
Note
Even though the fallback function cannot have arguments, one can still use msg.data to retrieve any payload supplied with the call.
Warning
The fallback function is also executed if the caller meant to call a function that is not available. If you want to implement the fallback function only to receive ether, you should add a check like require(msg.data.length == 0) to prevent invalid calls.
Warning
Contracts that receive Ether directly (without a function call, i.e. using send or transfer) but do not define a fallback function throw an exception, sending back the Ether (this was different before Solidity v0.4.0). So if you want your contract to receive Ether, you have to implement a payable fallback function.
Warning
A contract without a payable fallback function can receive Ether as a recipient of a coinbase transaction (aka miner block reward) or as a destination of a selfdestruct.
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 address(this).balance can be higher than the sum of some manual accounting implemented in a contract (i.e. having a counter updated in the fallback function).
pragma solidity >=0.5.0 <0.7.0;
contract Test {
// 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.function() external { x = 1; }
uint x;
}
// This contract keeps all Ether sent to it with no way// to get it back.contract Sink {
function() externalpayable { }
}
contract Caller {
function callTest(Test test) publicreturns (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 via an// intermediate conversion to ``uint160`` to even allow calling ``send`` on it.
address payable testPayable = address(uint160(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 Overloading
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 f in the scope of contract A.
pragma solidity >=0.4.16 <0.7.0;
contract A {
function f(uint _in) publicpurereturns (uint out) {
out = _in;
}
function f(uint _in, bool _really) publicpurereturns (uint out) {
if (_really)
out = _in;
}
}
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.
pragma solidity >=0.4.16 <0.7.0;
// This will not compilecontract A {
function f(B _in) publicpurereturns (B out) {
out = _in;
}
function f(address _in) publicpurereturns (address out) {
out = _in;
}
}
contract B {
}
Both f function overloads above end up accepting the address type for the ABI although they are considered different inside Solidity.
Overload resolution and Argument matching
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.
Note
Return parameters are not taken into account for overload resolution.
pragma solidity >=0.4.16 <0.7.0;
contract A {
function f(uint8 _in) publicpurereturns (uint8 out) {
out = _in;
}
function f(uint256 _in) publicpurereturns (uint256 out) {
out = _in;
}
}
Calling f(50) would create a type error since 50 can be implicitly converted both to uint8 and uint256 types. On another hand f(256) would resolve to f(uint256)overload as 256 cannot be implicitly converted to uint8.
Events
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 are inheritable members of contracts. 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, are incorporated into the blockchain, and stay there as long as a block is accessible (forever as of the Frontier and Homestead releases, but this might change with Serenity). 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 simple payment verification (SPV) for logs, so if an external entity supplies a contract with such a verification, 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 indexed to up to three parameters which adds them to a special data structure known as “topics” instead of the data part of the log. If you use arrays (including string and bytes) as indexed arguments, its Keccak-256 hash is stored as a topic instead, this is because a topic can only hold a single word (32 bytes).
All parameters without the indexed attribute are ABI-encoded 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 subscribe("logs")method to filter logs that match a topic with a certain address value:
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) {
});
The hash of the signature of the event is one of the topics, except if you declared the event with the anonymous specifier. This means that it is not possible to filter for specific anonymous events by name.
pragma solidity >=0.4.21 <0.7.0;
contract ClientReceipt {
event Deposit(
address indexed _from,
bytes32 indexed _id,
uint _value
);
function deposit(bytes32 _id) publicpayable {
// 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);
}
}
The use in the JavaScript API is as follows:
var abi = /* abi as generated by the compiler */;
var ClientReceipt = web3.eth.contract(abi);
var clientReceipt = ClientReceipt.at("0x1234...ab67" /* address */);
varevent = clientReceipt.Deposit();
// watch for changesevent.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 immediatelyvarevent = clientReceipt.Deposit(function(error, result) {
if (!error)
console.log(result);
});
The output of the above looks like the following (trimmed):
It is also possible to access the low-level interface to the logging mechanism via the functions log0, log1, log2, log3 and log4. logi takes i + 1 parameter of type bytes32, where the first argument will be used for the data part of the log and the others as topics. The event call above can be performed in the same way as
Solidity supports multiple inheritance including polymorphism.
All function calls are virtual, which means that the most derived function is called, except when the contract name is explicitly given or the super keyword is used.
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.
The general inheritance system is very similar to Python’s, especially concerning multiple inheritance, but there are also some differences.
Details are given in the following example.
pragma solidity >=0.5.0 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
// 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 mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
// 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.contract Config {
function lookup(uint id) publicreturns (address adr);
}
contract NameReg {
function register(bytes32 name) public;
function unregister() public;
}
// Multiple inheritance is possible. Note that `owned` is// also a base class of `mortal`, yet there is only a single// instance of `owned` (as for virtual inheritance in C++).contract named is owned, mortal {
constructor(bytes32 name) public {
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.function kill() public {
if (msg.sender == owner) {
Config config = Config(0xD5f9D8D94886E70b06E474c3fB14Fd43E2f23970);
NameReg(config.lookup(1)).unregister();
// It is still possible to call a specific// overridden function.
mortal.kill();
}
}
}
// 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, mortal, named("GoldFeed") {
function updateInfo(uint newInfo) public {
if (msg.sender == owner) info = newInfo;
}
function get() publicviewreturns(uint r) { return info; }
uint info;
}
Note that above, we call mortal.kill() to “forward” the destruction request. The way this is done is problematic, as seen in the following example:
pragma solidity >=0.4.22 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
contract mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
contract Base1 is mortal {
function kill() public { /* do cleanup 1 */ mortal.kill(); }
}
contract Base2 is mortal {
function kill() public { /* do cleanup 2 */ mortal.kill(); }
}
contract Final is Base1, Base2 {
}
A call to Final.kill() will call Base2.kill as the most derived override, but this function will bypass Base1.kill, basically because it does not even know about Base1. The way around this is to use super:
pragma solidity >=0.4.22 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
contract mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
contract Base1 is mortal {
function kill() public { /* do cleanup 1 */ super.kill(); }
}
contract Base2 is mortal {
function kill() public { /* do cleanup 2 */ super.kill(); }
}
contract Final is Base1, Base2 {
}
If Base2 calls a function of super, 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 Base1.kill() (note that the final inheritance sequence is – starting with the most derived contract: Final, Base2, Base1, mortal, 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.
Constructors
A constructor is an optional function declared with the constructor keyword which is executed upon contract creation, and where you can run contract initialisation code.
Before the constructor code is executed, state variables are initialised to their specified value if you initialise them inline, or zero 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.
Constructor functions can be either public or internal. If there is no constructor, the contract will assume the default constructor, which is equivalent to constructor() public {}. For example:
pragma solidity >=0.5.0 <0.7.0;
contract A {
uint public a;
constructor(uint _a) internal {
a = _a;
}
}
contract B is A(1) {
constructor() public {}
}
A constructor set as internal causes the contract to be marked as abstract.
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.
Arguments for Base Constructors
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:
pragma solidity >=0.4.22 <0.7.0;
contract Base {
uint x;
constructor(uint _x) public { x = _x; }
}
// Either directly specify in the inheritance list...contract Derived1 is Base(7) {
constructor() public {}
}
// or through a "modifier" of the derived constructor.contract Derived2 is Base {
constructor(uint _y) Base(_y * _y) public {}
}
One way is directly in the inheritance list (is Base(7)). The other is in the way a modifier is invoked as part of the derived constructor (Base(_y * _y)). The first way to do it is more convenient if the constructor argument is a constant and defines the behaviour 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 will be abstract.
Multiple Inheritance and Linearization
Languages that allow multiple inheritance have to deal with several problems. One is the Diamond Problem. Solidity is similar to Python in that it uses “C3 Linearization” 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 is 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”.
pragma solidity >=0.4.0 <0.7.0;
contract X {}
contract A is X {}
// This will not compilecontract C is A, X {}
The reason for this is that C requests X to override A (by specifying A, X in this order), but A itself requests to override X, which is a contradiction that cannot be resolved.
Inheriting Different Kinds of Members of the Same Name
When the inheritance results in a contract with a function and a modifier of the same name, it is considered as an error. This error is produced also by an event and a modifier of the same name, and a function and an event of the same name. As an exception, a state variable getter can override a public function.
Abstract Contracts
Contracts are marked as abstract when at least one of their functions lacks an implementation as in the following example (note that the function declaration header is terminated by ;):
Such contracts cannot be compiled (even if they contain implemented functions alongside non-implemented functions), but they can be used as base contracts:
pragma solidity >=0.4.0 <0.7.0;
contract Feline {
function utterance() publicreturns (bytes32);
}
contract Cat is Feline {
function utterance() publicreturns (bytes32) { return "miaow"; }
}
If a contract inherits from an abstract contract and does not implement all non-implemented functions by overriding, it will itself be abstract.
Note that a function without implementation is different from a Function Type even though their syntax looks very similar.
Example of function without implementation (a function declaration):
function foo(address) externalreturns (address);
Example of a Function Type (a variable declaration, where the variable is of type function):
function(address) externalreturns (address) foo;
Abstract contracts decouple the definition of a contract from its implementation providing better extensibility and self-documentation and facilitating patterns like the Template method 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”.
Interfaces
Interfaces are similar to abstract contracts, but they cannot have any functions implemented. There are further restrictions:
They cannot inherit other contracts or interfaces.
All declared functions must be external.
They cannot declare a constructor.
They cannot declare state variables.
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.
Contracts can inherit interfaces as they would inherit other contracts.
Types defined inside interfaces and other contract-like structures can be accessed from other contracts: Token.TokenType or Token.Coin.
Libraries
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 DELEGATECALL (CALLCODE 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. this 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 DELEGATECALL) if they do not modify the state (i.e. if they are view or pure functions), because libraries are assumed to be stateless. In particular, it is not possible to destroy a library.
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 mechanism that disallows state-modifying functions to be called directly (i.e. without DELEGATECALL).
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 (L.f() if L is the name of the library). Furthermore, internal functions of libraries are visible in all contracts, just as if the library were a base contract. Of course, calls to internal functions use the internal calling convention, which means that all internal types can be passed and types stored in memory will be passed by reference and not copied. To realize this in the EVM, code of internal library functions and all functions called from therein will at compile time be pulled into the calling contract, and a regular JUMP call will be used instead of a DELEGATECALL.
The following example illustrates how to use libraries (but manual method be sure to check out using for for a more advanced example to implement a set).
pragma solidity >=0.4.22 <0.7.0;
library Set {
// We define a new struct datatype that will be used to// hold its data in the calling contract.struct Data { mapping(uint => bool) flags; }
// 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)
publicreturns (bool)
{
if (self.flags[value])
returnfalse; // already there
self.flags[value] = true;
returntrue;
}
function remove(Data storage self, uint value)
publicreturns (bool)
{
if (!self.flags[value])
returnfalse; // not there
self.flags[value] = false;
returntrue;
}
function contains(Data storage self, uint value)
publicviewreturns (bool)
{
return self.flags[value];
}
}
contract C {
Set.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.
}
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 Set.contains, Set.insert and Set.remove are all compiled as calls (DELEGATECALL) to an external contract/library. If you use libraries, be aware that an actual external function call is performed. msg.sender, msg.value and this will retain their values in this call, though (prior to Homestead, because of the use of CALLCODE, msg.sender and msg.value changed, though).
The following example shows how to use types stored in memory and internal functions in libraries in order to implement custom types without the overhead of external function calls:
pragma solidity >=0.4.16 <0.7.0;
library BigInt {
struct bigint {
uint[] limbs;
}
function fromUint(uint x) internalpurereturns (bigint memory r) {
r.limbs = new uint[](1);
r.limbs[0] = x;
}
function add(bigint memory _a, bigint memory _b) internalpurereturns (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 a = limb(_a, i);
uint b = limb(_b, i);
r.limbs[i] = a + b + carry;
if (a + b < a || (a + b == uint(-1) && 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 _limb) internalpurereturns (uint) {
return _limb < _a.limbs.length ? _a.limbs[_limb] : 0;
}
function max(uint a, uint b) privatepurereturns (uint) {
return a > b ? a : b;
}
}
contract C {
using BigInt for BigInt.bigint;
function f() publicpure {
BigInt.bigint memory x = BigInt.fromUint(7);
BigInt.bigint memory y = BigInt.fromUint(uint(-1));
BigInt.bigint memory z = x.add(y);
assert(z.limb(1) > 0);
}
}
As the compiler cannot know where the library will be deployed at, these addresses have to be filled into the final bytecode by a linker (see Using the Commandline Compiler for how to use the commandline compiler for linking). If the addresses are not given as arguments to the compiler, the compiled hex code will contain placeholders of the form __Set______ (where Set is the name of the library). The address can be filled manually by replacing all those 40 symbols by the hex encoding of the address of the library contract.
Note
Manually linking libraries on the generated bytecode is discouraged, because it is restricted to 36 characters. You should ask the compiler to link the libraries at the time a contract is compiled by either using the --libraries option of solc or the libraries key if you use the standard-JSON interface to the compiler.
Restrictions for libraries in comparison to contracts:
No state variables
Cannot inherit nor be inherited
Cannot receive Ether
(These might be lifted at a later point.)
Call Protection For Libraries
As mentioned in the introduction, if a library’s code is executed using a CALL instead of a DELEGATECALL or CALLCODE, it will revert unless a view or pure function is called.
The EVM does not provide a direct way for a contract to detect whether it was called using CALL or not, but a contract can use the ADDRESS 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.
Using For
The directive using A for B; can be used to attach library functions (from the library A) to any type (B). These functions will receive the object they are called on as their first parameter (like the self variable in Python).
The effect of using A for *; is that the functions from the library A are attached to any type.
In both situations, all functions in the library are 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.
The using A for B; directive is active only within the current contract, including within all of its functions, and has no effect outside of the contract in which it is used. The directive may only be used inside a contract, not inside any of its functions.
By including a library, its data types including library functions are available without having to add further code.
Let us rewrite the set example from the Libraries in this way:
pragma solidity >=0.4.16 <0.7.0;
// This is the same code as before, just without commentslibrary Set {
struct Data { mapping(uint => bool) flags; }
function insert(Data storage self, uint value)
publicreturns (bool)
{
if (self.flags[value])
returnfalse; // already there
self.flags[value] = true;
returntrue;
}
function remove(Data storage self, uint value)
publicreturns (bool)
{
if (!self.flags[value])
returnfalse; // not there
self.flags[value] = false;
returntrue;
}
function contains(Data storage self, uint value)
publicviewreturns (bool)
{
return self.flags[value];
}
}
contract C {
using Set for Set.Data; // this is the crucial change
Set.Data knownValues;
function register(uint value) public {
// Here, all variables of type Set.Data have// corresponding member functions.// The following function call is identical to// `Set.insert(knownValues, value)`
require(knownValues.insert(value));
}
}
It is also possible to extend elementary types in that way:
pragma solidity >=0.4.16 <0.7.0;
library Search {
function indexOf(uint[] storage self, uint value)
publicviewreturns (uint)
{
for (uint i = 0; i < self.length; i++)
if (self[i] == value) return i;
return uint(-1);
}
}
contract C {
using Search for uint[];
uint[] data;
function append(uint value) public {
data.push(value);
}
function replace(uint _old, uint _new) public {
// This performs the library function call
uint index = data.indexOf(_old);
if (index == uint(-1))
data.push(_new);
else
data[index] = _new;
}
}
Note that all library calls are actual EVM function calls. This means that if you pass memory or value types, a copy will be performed, even of the self variable. The only situation where no copy will be performed is when storage reference variables are used.
Contracts
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 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.
Creating Contracts
Contracts can be created “from outside” via Ethereum transactions or from within Solidity contracts.
IDEs, such as Remix, make the creation process seamless using UI elements.
Creating contracts programmatically on Ethereum is best done via using the JavaScript API web3.js. It has a function called web3.eth.Contract to facilitate contract creation.
When a contract is created, its constructor (a function declared with the constructorkeyword) 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 deployed to 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 ABI encoded after the code of the contract itself, but you do not have to care about this if you use web3.js.
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.
pragma solidity >=0.4.22 <0.7.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) public {
// 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 do 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 check that.
creator = TokenCreator(msg.sender);
name = _name;
}
function changeName(bytes32 newName) public {
// Only the creator can alter the name --// the comparison is possible since contracts// are explicitly convertible to addresses.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)
publicreturns (OwnedToken tokenAddress)
{
// Create a new `Token` contract and return its address.// From the JavaScript side, the return type is// `address`, as this is the closest type available in// the ABI.returnnew 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 proceedfunction isTokenTransferOK(address currentOwner, address newOwner)
publicpurereturns (bool ok)
{
// Check an arbitrary condition to see if transfer should proceedreturn keccak256(abi.encodePacked(currentOwner, newOwner))[0] == 0x7f;
}
}
Visibility and Getters
Since Solidity knows two kinds of function calls (internal ones that do not create an actual EVM call (also called a “message call”) and external ones that do), there are four types of visibilities for functions and state variables.
Functions have to be specified as being external, public, internal or private. For state variables, external is not possible.external:External functions are part of the contract interface, which means they can be called from other contracts and via transactions. An external function f cannot be called internally (i.e. f() does not work, but this.f() works). External functions are sometimes more efficient when they receive large arrays of data.public:Public functions are part of the contract interface and can be either called internally or via messages. For public state variables, an automatic getter function (see below) is generated.internal:Those functions and state variables can only be accessed internally (i.e. from within the current contract or contracts deriving from it), without using this.private:Private functions and state variables are only visible for the contract they are defined in and not in derived contracts.
Note
Everything that is inside a contract is visible to all observers external to the blockchain. Making something private only prevents other contracts from accessing and modifying the information, but it will still be visible to the whole world outside of the blockchain.
The visibility specifier is given after the type for state variables and between parameter list and return parameter list for functions.
pragma solidity >=0.4.16 <0.7.0;
contract C {
function f(uint a) privatepurereturns (uint b) { return a + 1; }
function setData(uint a) internal { data = a; }
uint public data;
}
In the following example, D, can call c.getData() to retrieve the value of data in state storage, but is not able to call f. Contract E is derived from C and, thus, can call compute.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint private data;
function f(uint a) privatepurereturns(uint b) { return a + 1; }
function setData(uint a) public { data = a; }
function getData() publicviewreturns(uint) { return data; }
function compute(uint a, uint b) internalpurereturns (uint) { return a + b; }
}
// This will not compilecontract 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)
}
}
Getter Functions
The compiler automatically creates getter functions for all public state variables. For the contract given below, the compiler will generate a function called data that does not take any arguments and returns a uint, the value of the state variable data. State variables can be initialized when they are declared.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data = 42;
}
contract Caller {
C c = new C();
function f() publicviewreturns (uint) {
return c.data();
}
}
The getter functions have external visibility. If the symbol is accessed internally (i.e. without this.), it evaluates to a state variable. If it is accessed externally (i.e. with this.), it evaluates to a function.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data;
function x() publicreturns (uint) {
data = 3; // internal accessreturn this.data(); // external access
}
}
If you have a public 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 data(0). If you want to return an entire array in one call, then you need to write a function, for example:
pragma solidity >=0.4.0 <0.7.0;
contract arrayExample {
// public state variable
uint[] public myArray;
// Getter function generated by the compiler/* function myArray(uint i) returns (uint) { return myArray[i]; } */// function that returns entire arrayfunction getArray() returns (uint[] memory) {
return myArray;
}
}
Now you can use getArray() to retrieve the entire array, instead of myArray(i), which returns a single element per call.
It generates a function of the following form. The mapping in the struct is omitted because there is no good way to provide the key for the mapping:
function data(uint arg1, bool arg2, uint arg3) publicreturns (uint a, bytes3 b) {
a = data[arg1][arg2][arg3].a;
b = data[arg1][arg2][arg3].b;
}
Function Modifiers
Modifiers can be used to easily change the behaviour of functions. For example, they can automatically check a condition prior to executing the function. Modifiers are inheritable properties of contracts and may be overridden by derived contracts.
pragma solidity >=0.5.0 <0.7.0;
contract owned {
constructor() public { owner = 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 mortal is owned {
// This contract inherits the `onlyOwner` modifier from// `owned` and applies it to the `close` function, which// causes that calls to `close` only have an effect if// they are made by the stored owner.function close() public onlyOwner {
selfdestruct(owner);
}
}
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) public { 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() publicpayable costs(price) {
registeredAddresses[msg.sender] = true;
}
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;
}
}
Multiple modifiers are applied to a function by specifying them in a whitespace-separated list and are evaluated in the order presented.
Warning
In an earlier version of Solidity, return statements in functions having modifiers behaved differently.
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 “_” in the preceding modifier.
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).
Constant State Variables
State variables can be declared as constant. In this case, they have to be assigned from an expression which is a constant at compile time. Any expression that accesses storage, blockchain data (e.g. now, address(this).balance or block.number) or execution data (msg.value or gasleft()) 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 keccak256, sha256, ripemd160, ecrecover, addmod and mulmod are allowed (even though, with the exception of keccak256, 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.
The compiler does not reserve a storage slot for these variables, and every occurrence is replaced by the respective constant expression (which might be computed to a single value by the optimizer).
Not all types for constants are implemented at this time. The only supported types are value types and strings.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint constant x = 32**22 + 8;
string constant text = "abc";
bytes32 constant myHash = keccak256("abc");
}
Functions
Function Parameters and Return Variables
As in JavaScript, functions may take parameters as input. Unlike in JavaScript and C, functions may also return an arbitrary number of values as output.
Function Parameters
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:
pragma solidity >=0.4.16 <0.7.0;
contract Simple {
uint sum;
function taker(uint _a, uint _b) public {
sum = _a + _b;
}
}
Function parameters can be used as any other local variable and they can also be assigned to.
Note
An external function cannot accept a multi-dimensional array as an input parameter. This functionality is possible if you enable the new experimental ABIEncoderV2feature by adding pragma experimental ABIEncoderV2; to your source file.
An internal function can accept a multi-dimensional array without enabling the feature.
Return Variables
Function return variables are declared with the same syntax after the returns 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:
The names of return variables can be omitted. Return variables can be used as any other local variable and they are initialized with their default value and have that value unless explicitly set.
You can either explicitly assign to return variables and then leave the function using return;, or you can provide return values (either a single or multiple ones) directly with the return statement:
This form is equivalent to first assigning values to the return variables and then using return; to leave the function.
Note
You cannot return some types from non-internal functions, notably multi-dimensional dynamic arrays and structs. If you enable the new experimental ABIEncoderV2 feature by adding pragma experimental ABIEncoderV2; to your source file then more types are available, but mapping types are still limited to inside a single contract and you cannot transfer them.
Returning Multiple Values
When a function has multiple return types, the statement return (v0, v1, ..., vn)can be used to return multiple values. The number of components must be the same as the number of return types.
View Functions
Functions can be declared view in which case they promise not to modify the state.
Note
If the compiler’s EVM target is Byzantium or newer (default) the opcode STATICCALLis used for view functions which enforces the state to stay unmodified as part of the EVM execution. For library view functions DELEGATECALL is used, because there is no combined DELEGATECALL and STATICCALL. This means library view 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.
The following statements are considered modifying the state:
Using inline assembly that contains certain opcodes.
pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) publicviewreturns (uint) {
return a * (b + 42) + now;
}
}
Note
constant on functions used to be an alias to view, but this was dropped in version 0.5.0.
Note
Getter methods are automatically marked view.
Note
Prior to version 0.5.0, the compiler did not use the STATICCALL opcode for viewfunctions. This enabled state modifications in view functions through the use of invalid explicit type conversions. By using STATICCALL for view functions, modifications to the state are prevented on the level of the EVM.
Pure Functions
Functions can be declared pure in which case they promise not to read from or modify the state.
Note
If the compiler’s EVM target is Byzantium or newer (default) the opcode STATICCALLis used, which does not guarantee that the state is not read, but at least that it is not modified.
In addition to the list of state modifying statements explained above, the following are considered reading from the state:
Reading from state variables.
Accessing address(this).balance or <address>.balance.
Accessing any of the members of block, tx, msg (with the exception of msg.sigand msg.data).
Calling any function not marked pure.
Using inline assembly that contains certain opcodes.
pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) publicpurereturns (uint) {
return a * (b + 42);
}
}
Pure functions are able to use the revert() and require() functions to revert potential state changes when an error occurs.
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 view or pure restriction are reverted and that code has the option to catch the revert and not pass it on.
This behaviour is also in line with the STATICCALL opcode.
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 view can be enforced at the EVM level, pure can not).
Note
Prior to version 0.5.0, the compiler did not use the STATICCALL opcode for purefunctions. This enabled state modifications in pure functions through the use of invalid explicit type conversions. By using STATICCALL for pure functions, modifications to the state are prevented on the level of the EVM.
Note
Prior to version 0.4.17 the compiler did not enforce that pure is not reading the state. It is a compile-time type check, which can be circumvented 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.
Fallback Function
A contract can have exactly one unnamed function. This function cannot have arguments, cannot return anything and has to have external visibility. It is executed on a call to the contract if none of the other functions match the given function identifier (or if no data was supplied at all).
Furthermore, this function is executed whenever the contract receives plain Ether (without data). To receive Ether and add it to the total balance of the contract, the fallback function must be marked payable. If no such function exists, the contract cannot receive Ether through regular transactions and throws an exception.
In the worst case, the fallback function can only rely on 2300 gas being available (for example when send or transfer is used), leaving little room to perform other operations except basic logging. The following operations will consume more gas than the 2300 gas stipend:
Writing to storage
Creating a contract
Calling an external function which consumes a large amount of gas
Sending Ether
Like any function, the fallback function can execute complex operations as long as there is enough gas passed on to it.
Note
Even though the fallback function cannot have arguments, one can still use msg.data to retrieve any payload supplied with the call.
Warning
The fallback function is also executed if the caller meant to call a function that is not available. If you want to implement the fallback function only to receive ether, you should add a check like require(msg.data.length == 0) to prevent invalid calls.
Warning
Contracts that receive Ether directly (without a function call, i.e. using send or transfer) but do not define a fallback function throw an exception, sending back the Ether (this was different before Solidity v0.4.0). So if you want your contract to receive Ether, you have to implement a payable fallback function.
Warning
A contract without a payable fallback function can receive Ether as a recipient of a coinbase transaction (aka miner block reward) or as a destination of a selfdestruct.
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 address(this).balance can be higher than the sum of some manual accounting implemented in a contract (i.e. having a counter updated in the fallback function).
pragma solidity >=0.5.0 <0.7.0;
contract Test {
// 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.function() external { x = 1; }
uint x;
}
// This contract keeps all Ether sent to it with no way// to get it back.contract Sink {
function() externalpayable { }
}
contract Caller {
function callTest(Test test) publicreturns (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 via an// intermediate conversion to ``uint160`` to even allow calling ``send`` on it.
address payable testPayable = address(uint160(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 Overloading
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 f in the scope of contract A.
pragma solidity >=0.4.16 <0.7.0;
contract A {
function f(uint _in) publicpurereturns (uint out) {
out = _in;
}
function f(uint _in, bool _really) publicpurereturns (uint out) {
if (_really)
out = _in;
}
}
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.
pragma solidity >=0.4.16 <0.7.0;
// This will not compilecontract A {
function f(B _in) publicpurereturns (B out) {
out = _in;
}
function f(address _in) publicpurereturns (address out) {
out = _in;
}
}
contract B {
}
Both f function overloads above end up accepting the address type for the ABI although they are considered different inside Solidity.
Overload resolution and Argument matching
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.
Note
Return parameters are not taken into account for overload resolution.
pragma solidity >=0.4.16 <0.7.0;
contract A {
function f(uint8 _in) publicpurereturns (uint8 out) {
out = _in;
}
function f(uint256 _in) publicpurereturns (uint256 out) {
out = _in;
}
}
Calling f(50) would create a type error since 50 can be implicitly converted both to uint8 and uint256 types. On another hand f(256) would resolve to f(uint256)overload as 256 cannot be implicitly converted to uint8.
Events
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 are inheritable members of contracts. 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, are incorporated into the blockchain, and stay there as long as a block is accessible (forever as of the Frontier and Homestead releases, but this might change with Serenity). 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 simple payment verification (SPV) for logs, so if an external entity supplies a contract with such a verification, 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 indexed to up to three parameters which adds them to a special data structure known as “topics” instead of the data part of the log. If you use arrays (including string and bytes) as indexed arguments, its Keccak-256 hash is stored as a topic instead, this is because a topic can only hold a single word (32 bytes).
All parameters without the indexed attribute are ABI-encoded 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 subscribe("logs")method to filter logs that match a topic with a certain address value:
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) {
});
The hash of the signature of the event is one of the topics, except if you declared the event with the anonymous specifier. This means that it is not possible to filter for specific anonymous events by name.
pragma solidity >=0.4.21 <0.7.0;
contract ClientReceipt {
event Deposit(
address indexed _from,
bytes32 indexed _id,
uint _value
);
function deposit(bytes32 _id) publicpayable {
// 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);
}
}
The use in the JavaScript API is as follows:
var abi = /* abi as generated by the compiler */;
var ClientReceipt = web3.eth.contract(abi);
var clientReceipt = ClientReceipt.at("0x1234...ab67" /* address */);
varevent = clientReceipt.Deposit();
// watch for changesevent.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 immediatelyvarevent = clientReceipt.Deposit(function(error, result) {
if (!error)
console.log(result);
});
The output of the above looks like the following (trimmed):
It is also possible to access the low-level interface to the logging mechanism via the functions log0, log1, log2, log3 and log4. logi takes i + 1 parameter of type bytes32, where the first argument will be used for the data part of the log and the others as topics. The event call above can be performed in the same way as
Solidity supports multiple inheritance including polymorphism.
All function calls are virtual, which means that the most derived function is called, except when the contract name is explicitly given or the super keyword is used.
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.
The general inheritance system is very similar to Python’s, especially concerning multiple inheritance, but there are also some differences.
Details are given in the following example.
pragma solidity >=0.5.0 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
// 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 mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
// 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.contract Config {
function lookup(uint id) publicreturns (address adr);
}
contract NameReg {
function register(bytes32 name) public;
function unregister() public;
}
// Multiple inheritance is possible. Note that `owned` is// also a base class of `mortal`, yet there is only a single// instance of `owned` (as for virtual inheritance in C++).contract named is owned, mortal {
constructor(bytes32 name) public {
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.function kill() public {
if (msg.sender == owner) {
Config config = Config(0xD5f9D8D94886E70b06E474c3fB14Fd43E2f23970);
NameReg(config.lookup(1)).unregister();
// It is still possible to call a specific// overridden function.
mortal.kill();
}
}
}
// 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, mortal, named("GoldFeed") {
function updateInfo(uint newInfo) public {
if (msg.sender == owner) info = newInfo;
}
function get() publicviewreturns(uint r) { return info; }
uint info;
}
Note that above, we call mortal.kill() to “forward” the destruction request. The way this is done is problematic, as seen in the following example:
pragma solidity >=0.4.22 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
contract mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
contract Base1 is mortal {
function kill() public { /* do cleanup 1 */ mortal.kill(); }
}
contract Base2 is mortal {
function kill() public { /* do cleanup 2 */ mortal.kill(); }
}
contract Final is Base1, Base2 {
}
A call to Final.kill() will call Base2.kill as the most derived override, but this function will bypass Base1.kill, basically because it does not even know about Base1. The way around this is to use super:
pragma solidity >=0.4.22 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
contract mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
contract Base1 is mortal {
function kill() public { /* do cleanup 1 */ super.kill(); }
}
contract Base2 is mortal {
function kill() public { /* do cleanup 2 */ super.kill(); }
}
contract Final is Base1, Base2 {
}
If Base2 calls a function of super, 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 Base1.kill() (note that the final inheritance sequence is – starting with the most derived contract: Final, Base2, Base1, mortal, 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.
Constructors
A constructor is an optional function declared with the constructor keyword which is executed upon contract creation, and where you can run contract initialisation code.
Before the constructor code is executed, state variables are initialised to their specified value if you initialise them inline, or zero 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.
Constructor functions can be either public or internal. If there is no constructor, the contract will assume the default constructor, which is equivalent to constructor() public {}. For example:
pragma solidity >=0.5.0 <0.7.0;
contract A {
uint public a;
constructor(uint _a) internal {
a = _a;
}
}
contract B is A(1) {
constructor() public {}
}
A constructor set as internal causes the contract to be marked as abstract.
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.
Arguments for Base Constructors
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:
pragma solidity >=0.4.22 <0.7.0;
contract Base {
uint x;
constructor(uint _x) public { x = _x; }
}
// Either directly specify in the inheritance list...contract Derived1 is Base(7) {
constructor() public {}
}
// or through a "modifier" of the derived constructor.contract Derived2 is Base {
constructor(uint _y) Base(_y * _y) public {}
}
One way is directly in the inheritance list (is Base(7)). The other is in the way a modifier is invoked as part of the derived constructor (Base(_y * _y)). The first way to do it is more convenient if the constructor argument is a constant and defines the behaviour 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 will be abstract.
Multiple Inheritance and Linearization
Languages that allow multiple inheritance have to deal with several problems. One is the Diamond Problem. Solidity is similar to Python in that it uses “C3 Linearization” 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 is 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”.
pragma solidity >=0.4.0 <0.7.0;
contract X {}
contract A is X {}
// This will not compilecontract C is A, X {}
The reason for this is that C requests X to override A (by specifying A, X in this order), but A itself requests to override X, which is a contradiction that cannot be resolved.
Inheriting Different Kinds of Members of the Same Name
When the inheritance results in a contract with a function and a modifier of the same name, it is considered as an error. This error is produced also by an event and a modifier of the same name, and a function and an event of the same name. As an exception, a state variable getter can override a public function.
Abstract Contracts
Contracts are marked as abstract when at least one of their functions lacks an implementation as in the following example (note that the function declaration header is terminated by ;):
Such contracts cannot be compiled (even if they contain implemented functions alongside non-implemented functions), but they can be used as base contracts:
pragma solidity >=0.4.0 <0.7.0;
contract Feline {
function utterance() publicreturns (bytes32);
}
contract Cat is Feline {
function utterance() publicreturns (bytes32) { return "miaow"; }
}
If a contract inherits from an abstract contract and does not implement all non-implemented functions by overriding, it will itself be abstract.
Note that a function without implementation is different from a Function Type even though their syntax looks very similar.
Example of function without implementation (a function declaration):
function foo(address) externalreturns (address);
Example of a Function Type (a variable declaration, where the variable is of type function):
function(address) externalreturns (address) foo;
Abstract contracts decouple the definition of a contract from its implementation providing better extensibility and self-documentation and facilitating patterns like the Template method 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”.
Interfaces
Interfaces are similar to abstract contracts, but they cannot have any functions implemented. There are further restrictions:
They cannot inherit other contracts or interfaces.
All declared functions must be external.
They cannot declare a constructor.
They cannot declare state variables.
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.
Contracts can inherit interfaces as they would inherit other contracts.
Types defined inside interfaces and other contract-like structures can be accessed from other contracts: Token.TokenType or Token.Coin.
Libraries
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 DELEGATECALL (CALLCODE 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. this 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 DELEGATECALL) if they do not modify the state (i.e. if they are view or pure functions), because libraries are assumed to be stateless. In particular, it is not possible to destroy a library.
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 mechanism that disallows state-modifying functions to be called directly (i.e. without DELEGATECALL).
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 (L.f() if L is the name of the library). Furthermore, internal functions of libraries are visible in all contracts, just as if the library were a base contract. Of course, calls to internal functions use the internal calling convention, which means that all internal types can be passed and types stored in memory will be passed by reference and not copied. To realize this in the EVM, code of internal library functions and all functions called from therein will at compile time be pulled into the calling contract, and a regular JUMP call will be used instead of a DELEGATECALL.
The following example illustrates how to use libraries (but manual method be sure to check out using for for a more advanced example to implement a set).
pragma solidity >=0.4.22 <0.7.0;
library Set {
// We define a new struct datatype that will be used to// hold its data in the calling contract.struct Data { mapping(uint => bool) flags; }
// 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)
publicreturns (bool)
{
if (self.flags[value])
returnfalse; // already there
self.flags[value] = true;
returntrue;
}
function remove(Data storage self, uint value)
publicreturns (bool)
{
if (!self.flags[value])
returnfalse; // not there
self.flags[value] = false;
returntrue;
}
function contains(Data storage self, uint value)
publicviewreturns (bool)
{
return self.flags[value];
}
}
contract C {
Set.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.
}
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 Set.contains, Set.insert and Set.remove are all compiled as calls (DELEGATECALL) to an external contract/library. If you use libraries, be aware that an actual external function call is performed. msg.sender, msg.value and this will retain their values in this call, though (prior to Homestead, because of the use of CALLCODE, msg.sender and msg.value changed, though).
The following example shows how to use types stored in memory and internal functions in libraries in order to implement custom types without the overhead of external function calls:
pragma solidity >=0.4.16 <0.7.0;
library BigInt {
struct bigint {
uint[] limbs;
}
function fromUint(uint x) internalpurereturns (bigint memory r) {
r.limbs = new uint[](1);
r.limbs[0] = x;
}
function add(bigint memory _a, bigint memory _b) internalpurereturns (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 a = limb(_a, i);
uint b = limb(_b, i);
r.limbs[i] = a + b + carry;
if (a + b < a || (a + b == uint(-1) && 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 _limb) internalpurereturns (uint) {
return _limb < _a.limbs.length ? _a.limbs[_limb] : 0;
}
function max(uint a, uint b) privatepurereturns (uint) {
return a > b ? a : b;
}
}
contract C {
using BigInt for BigInt.bigint;
function f() publicpure {
BigInt.bigint memory x = BigInt.fromUint(7);
BigInt.bigint memory y = BigInt.fromUint(uint(-1));
BigInt.bigint memory z = x.add(y);
assert(z.limb(1) > 0);
}
}
As the compiler cannot know where the library will be deployed at, these addresses have to be filled into the final bytecode by a linker (see Using the Commandline Compiler for how to use the commandline compiler for linking). If the addresses are not given as arguments to the compiler, the compiled hex code will contain placeholders of the form __Set______ (where Set is the name of the library). The address can be filled manually by replacing all those 40 symbols by the hex encoding of the address of the library contract.
Note
Manually linking libraries on the generated bytecode is discouraged, because it is restricted to 36 characters. You should ask the compiler to link the libraries at the time a contract is compiled by either using the --libraries option of solc or the libraries key if you use the standard-JSON interface to the compiler.
Restrictions for libraries in comparison to contracts:
No state variables
Cannot inherit nor be inherited
Cannot receive Ether
(These might be lifted at a later point.)
Call Protection For Libraries
As mentioned in the introduction, if a library’s code is executed using a CALL instead of a DELEGATECALL or CALLCODE, it will revert unless a view or pure function is called.
The EVM does not provide a direct way for a contract to detect whether it was called using CALL or not, but a contract can use the ADDRESS 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.
Using For
The directive using A for B; can be used to attach library functions (from the library A) to any type (B). These functions will receive the object they are called on as their first parameter (like the self variable in Python).
The effect of using A for *; is that the functions from the library A are attached to any type.
In both situations, all functions in the library are 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.
The using A for B; directive is active only within the current contract, including within all of its functions, and has no effect outside of the contract in which it is used. The directive may only be used inside a contract, not inside any of its functions.
By including a library, its data types including library functions are available without having to add further code.
Let us rewrite the set example from the Libraries in this way:
pragma solidity >=0.4.16 <0.7.0;
// This is the same code as before, just without commentslibrary Set {
struct Data { mapping(uint => bool) flags; }
function insert(Data storage self, uint value)
publicreturns (bool)
{
if (self.flags[value])
returnfalse; // already there
self.flags[value] = true;
returntrue;
}
function remove(Data storage self, uint value)
publicreturns (bool)
{
if (!self.flags[value])
returnfalse; // not there
self.flags[value] = false;
returntrue;
}
function contains(Data storage self, uint value)
publicviewreturns (bool)
{
return self.flags[value];
}
}
contract C {
using Set for Set.Data; // this is the crucial change
Set.Data knownValues;
function register(uint value) public {
// Here, all variables of type Set.Data have// corresponding member functions.// The following function call is identical to// `Set.insert(knownValues, value)`
require(knownValues.insert(value));
}
}
It is also possible to extend elementary types in that way:
pragma solidity >=0.4.16 <0.7.0;
library Search {
function indexOf(uint[] storage self, uint value)
publicviewreturns (uint)
{
for (uint i = 0; i < self.length; i++)
if (self[i] == value) return i;
return uint(-1);
}
}
contract C {
using Search for uint[];
uint[] data;
function append(uint value) public {
data.push(value);
}
function replace(uint _old, uint _new) public {
// This performs the library function call
uint index = data.indexOf(_old);
if (index == uint(-1))
data.push(_new);
else
data[index] = _new;
}
}
Note that all library calls are actual EVM function calls. This means that if you pass memory or value types, a copy will be performed, even of the self variable. The only situation where no copy will be performed is when storage reference variables are used.
Contracts
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 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.
Creating Contracts
Contracts can be created “from outside” via Ethereum transactions or from within Solidity contracts.
IDEs, such as Remix, make the creation process seamless using UI elements.
Creating contracts programmatically on Ethereum is best done via using the JavaScript API web3.js. It has a function called web3.eth.Contract to facilitate contract creation.
When a contract is created, its constructor (a function declared with the constructorkeyword) 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 deployed to 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 ABI encoded after the code of the contract itself, but you do not have to care about this if you use web3.js.
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.
pragma solidity >=0.4.22 <0.7.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) public {
// 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 do 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 check that.
creator = TokenCreator(msg.sender);
name = _name;
}
function changeName(bytes32 newName) public {
// Only the creator can alter the name --// the comparison is possible since contracts// are explicitly convertible to addresses.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)
publicreturns (OwnedToken tokenAddress)
{
// Create a new `Token` contract and return its address.// From the JavaScript side, the return type is// `address`, as this is the closest type available in// the ABI.returnnew 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 proceedfunction isTokenTransferOK(address currentOwner, address newOwner)
publicpurereturns (bool ok)
{
// Check an arbitrary condition to see if transfer should proceedreturn keccak256(abi.encodePacked(currentOwner, newOwner))[0] == 0x7f;
}
}
Visibility and Getters
Since Solidity knows two kinds of function calls (internal ones that do not create an actual EVM call (also called a “message call”) and external ones that do), there are four types of visibilities for functions and state variables.
Functions have to be specified as being external, public, internal or private. For state variables, external is not possible.external:External functions are part of the contract interface, which means they can be called from other contracts and via transactions. An external function f cannot be called internally (i.e. f() does not work, but this.f() works). External functions are sometimes more efficient when they receive large arrays of data.public:Public functions are part of the contract interface and can be either called internally or via messages. For public state variables, an automatic getter function (see below) is generated.internal:Those functions and state variables can only be accessed internally (i.e. from within the current contract or contracts deriving from it), without using this.private:Private functions and state variables are only visible for the contract they are defined in and not in derived contracts.
Note
Everything that is inside a contract is visible to all observers external to the blockchain. Making something private only prevents other contracts from accessing and modifying the information, but it will still be visible to the whole world outside of the blockchain.
The visibility specifier is given after the type for state variables and between parameter list and return parameter list for functions.
pragma solidity >=0.4.16 <0.7.0;
contract C {
function f(uint a) privatepurereturns (uint b) { return a + 1; }
function setData(uint a) internal { data = a; }
uint public data;
}
In the following example, D, can call c.getData() to retrieve the value of data in state storage, but is not able to call f. Contract E is derived from C and, thus, can call compute.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint private data;
function f(uint a) privatepurereturns(uint b) { return a + 1; }
function setData(uint a) public { data = a; }
function getData() publicviewreturns(uint) { return data; }
function compute(uint a, uint b) internalpurereturns (uint) { return a + b; }
}
// This will not compilecontract 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)
}
}
Getter Functions
The compiler automatically creates getter functions for all public state variables. For the contract given below, the compiler will generate a function called data that does not take any arguments and returns a uint, the value of the state variable data. State variables can be initialized when they are declared.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data = 42;
}
contract Caller {
C c = new C();
function f() publicviewreturns (uint) {
return c.data();
}
}
The getter functions have external visibility. If the symbol is accessed internally (i.e. without this.), it evaluates to a state variable. If it is accessed externally (i.e. with this.), it evaluates to a function.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint public data;
function x() publicreturns (uint) {
data = 3; // internal accessreturn this.data(); // external access
}
}
If you have a public 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 data(0). If you want to return an entire array in one call, then you need to write a function, for example:
pragma solidity >=0.4.0 <0.7.0;
contract arrayExample {
// public state variable
uint[] public myArray;
// Getter function generated by the compiler/* function myArray(uint i) returns (uint) { return myArray[i]; } */// function that returns entire arrayfunction getArray() returns (uint[] memory) {
return myArray;
}
}
Now you can use getArray() to retrieve the entire array, instead of myArray(i), which returns a single element per call.
It generates a function of the following form. The mapping in the struct is omitted because there is no good way to provide the key for the mapping:
function data(uint arg1, bool arg2, uint arg3) publicreturns (uint a, bytes3 b) {
a = data[arg1][arg2][arg3].a;
b = data[arg1][arg2][arg3].b;
}
Function Modifiers
Modifiers can be used to easily change the behaviour of functions. For example, they can automatically check a condition prior to executing the function. Modifiers are inheritable properties of contracts and may be overridden by derived contracts.
pragma solidity >=0.5.0 <0.7.0;
contract owned {
constructor() public { owner = 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 mortal is owned {
// This contract inherits the `onlyOwner` modifier from// `owned` and applies it to the `close` function, which// causes that calls to `close` only have an effect if// they are made by the stored owner.function close() public onlyOwner {
selfdestruct(owner);
}
}
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) public { 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() publicpayable costs(price) {
registeredAddresses[msg.sender] = true;
}
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;
}
}
Multiple modifiers are applied to a function by specifying them in a whitespace-separated list and are evaluated in the order presented.
Warning
In an earlier version of Solidity, return statements in functions having modifiers behaved differently.
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 “_” in the preceding modifier.
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).
Constant State Variables
State variables can be declared as constant. In this case, they have to be assigned from an expression which is a constant at compile time. Any expression that accesses storage, blockchain data (e.g. now, address(this).balance or block.number) or execution data (msg.value or gasleft()) 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 keccak256, sha256, ripemd160, ecrecover, addmod and mulmod are allowed (even though, with the exception of keccak256, 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.
The compiler does not reserve a storage slot for these variables, and every occurrence is replaced by the respective constant expression (which might be computed to a single value by the optimizer).
Not all types for constants are implemented at this time. The only supported types are value types and strings.
pragma solidity >=0.4.0 <0.7.0;
contract C {
uint constant x = 32**22 + 8;
string constant text = "abc";
bytes32 constant myHash = keccak256("abc");
}
Functions
Function Parameters and Return Variables
As in JavaScript, functions may take parameters as input. Unlike in JavaScript and C, functions may also return an arbitrary number of values as output.
Function Parameters
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:
pragma solidity >=0.4.16 <0.7.0;
contract Simple {
uint sum;
function taker(uint _a, uint _b) public {
sum = _a + _b;
}
}
Function parameters can be used as any other local variable and they can also be assigned to.
Note
An external function cannot accept a multi-dimensional array as an input parameter. This functionality is possible if you enable the new experimental ABIEncoderV2feature by adding pragma experimental ABIEncoderV2; to your source file.
An internal function can accept a multi-dimensional array without enabling the feature.
Return Variables
Function return variables are declared with the same syntax after the returns 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:
The names of return variables can be omitted. Return variables can be used as any other local variable and they are initialized with their default value and have that value unless explicitly set.
You can either explicitly assign to return variables and then leave the function using return;, or you can provide return values (either a single or multiple ones) directly with the return statement:
This form is equivalent to first assigning values to the return variables and then using return; to leave the function.
Note
You cannot return some types from non-internal functions, notably multi-dimensional dynamic arrays and structs. If you enable the new experimental ABIEncoderV2 feature by adding pragma experimental ABIEncoderV2; to your source file then more types are available, but mapping types are still limited to inside a single contract and you cannot transfer them.
Returning Multiple Values
When a function has multiple return types, the statement return (v0, v1, ..., vn)can be used to return multiple values. The number of components must be the same as the number of return types.
View Functions
Functions can be declared view in which case they promise not to modify the state.
Note
If the compiler’s EVM target is Byzantium or newer (default) the opcode STATICCALLis used for view functions which enforces the state to stay unmodified as part of the EVM execution. For library view functions DELEGATECALL is used, because there is no combined DELEGATECALL and STATICCALL. This means library view 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.
The following statements are considered modifying the state:
Using inline assembly that contains certain opcodes.
pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) publicviewreturns (uint) {
return a * (b + 42) + now;
}
}
Note
constant on functions used to be an alias to view, but this was dropped in version 0.5.0.
Note
Getter methods are automatically marked view.
Note
Prior to version 0.5.0, the compiler did not use the STATICCALL opcode for viewfunctions. This enabled state modifications in view functions through the use of invalid explicit type conversions. By using STATICCALL for view functions, modifications to the state are prevented on the level of the EVM.
Pure Functions
Functions can be declared pure in which case they promise not to read from or modify the state.
Note
If the compiler’s EVM target is Byzantium or newer (default) the opcode STATICCALLis used, which does not guarantee that the state is not read, but at least that it is not modified.
In addition to the list of state modifying statements explained above, the following are considered reading from the state:
Reading from state variables.
Accessing address(this).balance or <address>.balance.
Accessing any of the members of block, tx, msg (with the exception of msg.sigand msg.data).
Calling any function not marked pure.
Using inline assembly that contains certain opcodes.
pragma solidity >=0.5.0 <0.7.0;
contract C {
function f(uint a, uint b) publicpurereturns (uint) {
return a * (b + 42);
}
}
Pure functions are able to use the revert() and require() functions to revert potential state changes when an error occurs.
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 view or pure restriction are reverted and that code has the option to catch the revert and not pass it on.
This behaviour is also in line with the STATICCALL opcode.
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 view can be enforced at the EVM level, pure can not).
Note
Prior to version 0.5.0, the compiler did not use the STATICCALL opcode for purefunctions. This enabled state modifications in pure functions through the use of invalid explicit type conversions. By using STATICCALL for pure functions, modifications to the state are prevented on the level of the EVM.
Note
Prior to version 0.4.17 the compiler did not enforce that pure is not reading the state. It is a compile-time type check, which can be circumvented 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.
Fallback Function
A contract can have exactly one unnamed function. This function cannot have arguments, cannot return anything and has to have external visibility. It is executed on a call to the contract if none of the other functions match the given function identifier (or if no data was supplied at all).
Furthermore, this function is executed whenever the contract receives plain Ether (without data). To receive Ether and add it to the total balance of the contract, the fallback function must be marked payable. If no such function exists, the contract cannot receive Ether through regular transactions and throws an exception.
In the worst case, the fallback function can only rely on 2300 gas being available (for example when send or transfer is used), leaving little room to perform other operations except basic logging. The following operations will consume more gas than the 2300 gas stipend:
Writing to storage
Creating a contract
Calling an external function which consumes a large amount of gas
Sending Ether
Like any function, the fallback function can execute complex operations as long as there is enough gas passed on to it.
Note
Even though the fallback function cannot have arguments, one can still use msg.data to retrieve any payload supplied with the call.
Warning
The fallback function is also executed if the caller meant to call a function that is not available. If you want to implement the fallback function only to receive ether, you should add a check like require(msg.data.length == 0) to prevent invalid calls.
Warning
Contracts that receive Ether directly (without a function call, i.e. using send or transfer) but do not define a fallback function throw an exception, sending back the Ether (this was different before Solidity v0.4.0). So if you want your contract to receive Ether, you have to implement a payable fallback function.
Warning
A contract without a payable fallback function can receive Ether as a recipient of a coinbase transaction (aka miner block reward) or as a destination of a selfdestruct.
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 address(this).balance can be higher than the sum of some manual accounting implemented in a contract (i.e. having a counter updated in the fallback function).
pragma solidity >=0.5.0 <0.7.0;
contract Test {
// 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.function() external { x = 1; }
uint x;
}
// This contract keeps all Ether sent to it with no way// to get it back.contract Sink {
function() externalpayable { }
}
contract Caller {
function callTest(Test test) publicreturns (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 via an// intermediate conversion to ``uint160`` to even allow calling ``send`` on it.
address payable testPayable = address(uint160(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 Overloading
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 f in the scope of contract A.
pragma solidity >=0.4.16 <0.7.0;
contract A {
function f(uint _in) publicpurereturns (uint out) {
out = _in;
}
function f(uint _in, bool _really) publicpurereturns (uint out) {
if (_really)
out = _in;
}
}
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.
pragma solidity >=0.4.16 <0.7.0;
// This will not compilecontract A {
function f(B _in) publicpurereturns (B out) {
out = _in;
}
function f(address _in) publicpurereturns (address out) {
out = _in;
}
}
contract B {
}
Both f function overloads above end up accepting the address type for the ABI although they are considered different inside Solidity.
Overload resolution and Argument matching
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.
Note
Return parameters are not taken into account for overload resolution.
pragma solidity >=0.4.16 <0.7.0;
contract A {
function f(uint8 _in) publicpurereturns (uint8 out) {
out = _in;
}
function f(uint256 _in) publicpurereturns (uint256 out) {
out = _in;
}
}
Calling f(50) would create a type error since 50 can be implicitly converted both to uint8 and uint256 types. On another hand f(256) would resolve to f(uint256)overload as 256 cannot be implicitly converted to uint8.
Events
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 are inheritable members of contracts. 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, are incorporated into the blockchain, and stay there as long as a block is accessible (forever as of the Frontier and Homestead releases, but this might change with Serenity). 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 simple payment verification (SPV) for logs, so if an external entity supplies a contract with such a verification, 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 indexed to up to three parameters which adds them to a special data structure known as “topics” instead of the data part of the log. If you use arrays (including string and bytes) as indexed arguments, its Keccak-256 hash is stored as a topic instead, this is because a topic can only hold a single word (32 bytes).
All parameters without the indexed attribute are ABI-encoded 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 subscribe("logs")method to filter logs that match a topic with a certain address value:
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) {
});
The hash of the signature of the event is one of the topics, except if you declared the event with the anonymous specifier. This means that it is not possible to filter for specific anonymous events by name.
pragma solidity >=0.4.21 <0.7.0;
contract ClientReceipt {
event Deposit(
address indexed _from,
bytes32 indexed _id,
uint _value
);
function deposit(bytes32 _id) publicpayable {
// 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);
}
}
The use in the JavaScript API is as follows:
var abi = /* abi as generated by the compiler */;
var ClientReceipt = web3.eth.contract(abi);
var clientReceipt = ClientReceipt.at("0x1234...ab67" /* address */);
varevent = clientReceipt.Deposit();
// watch for changesevent.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 immediatelyvarevent = clientReceipt.Deposit(function(error, result) {
if (!error)
console.log(result);
});
The output of the above looks like the following (trimmed):
It is also possible to access the low-level interface to the logging mechanism via the functions log0, log1, log2, log3 and log4. logi takes i + 1 parameter of type bytes32, where the first argument will be used for the data part of the log and the others as topics. The event call above can be performed in the same way as
Solidity supports multiple inheritance including polymorphism.
All function calls are virtual, which means that the most derived function is called, except when the contract name is explicitly given or the super keyword is used.
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.
The general inheritance system is very similar to Python’s, especially concerning multiple inheritance, but there are also some differences.
Details are given in the following example.
pragma solidity >=0.5.0 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
// 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 mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
// 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.contract Config {
function lookup(uint id) publicreturns (address adr);
}
contract NameReg {
function register(bytes32 name) public;
function unregister() public;
}
// Multiple inheritance is possible. Note that `owned` is// also a base class of `mortal`, yet there is only a single// instance of `owned` (as for virtual inheritance in C++).contract named is owned, mortal {
constructor(bytes32 name) public {
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.function kill() public {
if (msg.sender == owner) {
Config config = Config(0xD5f9D8D94886E70b06E474c3fB14Fd43E2f23970);
NameReg(config.lookup(1)).unregister();
// It is still possible to call a specific// overridden function.
mortal.kill();
}
}
}
// 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, mortal, named("GoldFeed") {
function updateInfo(uint newInfo) public {
if (msg.sender == owner) info = newInfo;
}
function get() publicviewreturns(uint r) { return info; }
uint info;
}
Note that above, we call mortal.kill() to “forward” the destruction request. The way this is done is problematic, as seen in the following example:
pragma solidity >=0.4.22 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
contract mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
contract Base1 is mortal {
function kill() public { /* do cleanup 1 */ mortal.kill(); }
}
contract Base2 is mortal {
function kill() public { /* do cleanup 2 */ mortal.kill(); }
}
contract Final is Base1, Base2 {
}
A call to Final.kill() will call Base2.kill as the most derived override, but this function will bypass Base1.kill, basically because it does not even know about Base1. The way around this is to use super:
pragma solidity >=0.4.22 <0.7.0;
contract owned {
constructor() public { owner = msg.sender; }
address payable owner;
}
contract mortal is owned {
function kill() public {
if (msg.sender == owner) selfdestruct(owner);
}
}
contract Base1 is mortal {
function kill() public { /* do cleanup 1 */ super.kill(); }
}
contract Base2 is mortal {
function kill() public { /* do cleanup 2 */ super.kill(); }
}
contract Final is Base1, Base2 {
}
If Base2 calls a function of super, 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 Base1.kill() (note that the final inheritance sequence is – starting with the most derived contract: Final, Base2, Base1, mortal, 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.
Constructors
A constructor is an optional function declared with the constructor keyword which is executed upon contract creation, and where you can run contract initialisation code.
Before the constructor code is executed, state variables are initialised to their specified value if you initialise them inline, or zero 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.
Constructor functions can be either public or internal. If there is no constructor, the contract will assume the default constructor, which is equivalent to constructor() public {}. For example:
pragma solidity >=0.5.0 <0.7.0;
contract A {
uint public a;
constructor(uint _a) internal {
a = _a;
}
}
contract B is A(1) {
constructor() public {}
}
A constructor set as internal causes the contract to be marked as abstract.
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.
Arguments for Base Constructors
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:
pragma solidity >=0.4.22 <0.7.0;
contract Base {
uint x;
constructor(uint _x) public { x = _x; }
}
// Either directly specify in the inheritance list...contract Derived1 is Base(7) {
constructor() public {}
}
// or through a "modifier" of the derived constructor.contract Derived2 is Base {
constructor(uint _y) Base(_y * _y) public {}
}
One way is directly in the inheritance list (is Base(7)). The other is in the way a modifier is invoked as part of the derived constructor (Base(_y * _y)). The first way to do it is more convenient if the constructor argument is a constant and defines the behaviour 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 will be abstract.
Multiple Inheritance and Linearization
Languages that allow multiple inheritance have to deal with several problems. One is the Diamond Problem. Solidity is similar to Python in that it uses “C3 Linearization” 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 is 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”.
pragma solidity >=0.4.0 <0.7.0;
contract X {}
contract A is X {}
// This will not compilecontract C is A, X {}
The reason for this is that C requests X to override A (by specifying A, X in this order), but A itself requests to override X, which is a contradiction that cannot be resolved.
Inheriting Different Kinds of Members of the Same Name
When the inheritance results in a contract with a function and a modifier of the same name, it is considered as an error. This error is produced also by an event and a modifier of the same name, and a function and an event of the same name. As an exception, a state variable getter can override a public function.
Abstract Contracts
Contracts are marked as abstract when at least one of their functions lacks an implementation as in the following example (note that the function declaration header is terminated by ;):
Such contracts cannot be compiled (even if they contain implemented functions alongside non-implemented functions), but they can be used as base contracts:
pragma solidity >=0.4.0 <0.7.0;
contract Feline {
function utterance() publicreturns (bytes32);
}
contract Cat is Feline {
function utterance() publicreturns (bytes32) { return "miaow"; }
}
If a contract inherits from an abstract contract and does not implement all non-implemented functions by overriding, it will itself be abstract.
Note that a function without implementation is different from a Function Type even though their syntax looks very similar.
Example of function without implementation (a function declaration):
function foo(address) externalreturns (address);
Example of a Function Type (a variable declaration, where the variable is of type function):
function(address) externalreturns (address) foo;
Abstract contracts decouple the definition of a contract from its implementation providing better extensibility and self-documentation and facilitating patterns like the Template method 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”.
Interfaces
Interfaces are similar to abstract contracts, but they cannot have any functions implemented. There are further restrictions:
They cannot inherit other contracts or interfaces.
All declared functions must be external.
They cannot declare a constructor.
They cannot declare state variables.
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.
Contracts can inherit interfaces as they would inherit other contracts.
Types defined inside interfaces and other contract-like structures can be accessed from other contracts: Token.TokenType or Token.Coin.
Libraries
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 DELEGATECALL (CALLCODE 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. this 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 DELEGATECALL) if they do not modify the state (i.e. if they are view or pure functions), because libraries are assumed to be stateless. In particular, it is not possible to destroy a library.
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 mechanism that disallows state-modifying functions to be called directly (i.e. without DELEGATECALL).
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 (L.f() if L is the name of the library). Furthermore, internal functions of libraries are visible in all contracts, just as if the library were a base contract. Of course, calls to internal functions use the internal calling convention, which means that all internal types can be passed and types stored in memory will be passed by reference and not copied. To realize this in the EVM, code of internal library functions and all functions called from therein will at compile time be pulled into the calling contract, and a regular JUMP call will be used instead of a DELEGATECALL.
The following example illustrates how to use libraries (but manual method be sure to check out using for for a more advanced example to implement a set).
pragma solidity >=0.4.22 <0.7.0;
library Set {
// We define a new struct datatype that will be used to// hold its data in the calling contract.struct Data { mapping(uint => bool) flags; }
// 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)
publicreturns (bool)
{
if (self.flags[value])
returnfalse; // already there
self.flags[value] = true;
returntrue;
}
function remove(Data storage self, uint value)
publicreturns (bool)
{
if (!self.flags[value])
returnfalse; // not there
self.flags[value] = false;
returntrue;
}
function contains(Data storage self, uint value)
publicviewreturns (bool)
{
return self.flags[value];
}
}
contract C {
Set.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.
}
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 Set.contains, Set.insert and Set.remove are all compiled as calls (DELEGATECALL) to an external contract/library. If you use libraries, be aware that an actual external function call is performed. msg.sender, msg.value and this will retain their values in this call, though (prior to Homestead, because of the use of CALLCODE, msg.sender and msg.value changed, though).
The following example shows how to use types stored in memory and internal functions in libraries in order to implement custom types without the overhead of external function calls:
pragma solidity >=0.4.16 <0.7.0;
library BigInt {
struct bigint {
uint[] limbs;
}
function fromUint(uint x) internalpurereturns (bigint memory r) {
r.limbs = new uint[](1);
r.limbs[0] = x;
}
function add(bigint memory _a, bigint memory _b) internalpurereturns (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 a = limb(_a, i);
uint b = limb(_b, i);
r.limbs[i] = a + b + carry;
if (a + b < a || (a + b == uint(-1) && 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 _limb) internalpurereturns (uint) {
return _limb < _a.limbs.length ? _a.limbs[_limb] : 0;
}
function max(uint a, uint b) privatepurereturns (uint) {
return a > b ? a : b;
}
}
contract C {
using BigInt for BigInt.bigint;
function f() publicpure {
BigInt.bigint memory x = BigInt.fromUint(7);
BigInt.bigint memory y = BigInt.fromUint(uint(-1));
BigInt.bigint memory z = x.add(y);
assert(z.limb(1) > 0);
}
}
As the compiler cannot know where the library will be deployed at, these addresses have to be filled into the final bytecode by a linker (see Using the Commandline Compiler for how to use the commandline compiler for linking). If the addresses are not given as arguments to the compiler, the compiled hex code will contain placeholders of the form __Set______ (where Set is the name of the library). The address can be filled manually by replacing all those 40 symbols by the hex encoding of the address of the library contract.
Note
Manually linking libraries on the generated bytecode is discouraged, because it is restricted to 36 characters. You should ask the compiler to link the libraries at the time a contract is compiled by either using the --libraries option of solc or the libraries key if you use the standard-JSON interface to the compiler.
Restrictions for libraries in comparison to contracts:
No state variables
Cannot inherit nor be inherited
Cannot receive Ether
(These might be lifted at a later point.)
Call Protection For Libraries
As mentioned in the introduction, if a library’s code is executed using a CALL instead of a DELEGATECALL or CALLCODE, it will revert unless a view or pure function is called.
The EVM does not provide a direct way for a contract to detect whether it was called using CALL or not, but a contract can use the ADDRESS 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.
Using For
The directive using A for B; can be used to attach library functions (from the library A) to any type (B). These functions will receive the object they are called on as their first parameter (like the self variable in Python).
The effect of using A for *; is that the functions from the library A are attached to any type.
In both situations, all functions in the library are 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.
The using A for B; directive is active only within the current contract, including within all of its functions, and has no effect outside of the contract in which it is used. The directive may only be used inside a contract, not inside any of its functions.
By including a library, its data types including library functions are available without having to add further code.
Let us rewrite the set example from the Libraries in this way:
pragma solidity >=0.4.16 <0.7.0;
// This is the same code as before, just without commentslibrary Set {
struct Data { mapping(uint => bool) flags; }
function insert(Data storage self, uint value)
publicreturns (bool)
{
if (self.flags[value])
returnfalse; // already there
self.flags[value] = true;
returntrue;
}
function remove(Data storage self, uint value)
publicreturns (bool)
{
if (!self.flags[value])
returnfalse; // not there
self.flags[value] = false;
returntrue;
}
function contains(Data storage self, uint value)
publicviewreturns (bool)
{
return self.flags[value];
}
}
contract C {
using Set for Set.Data; // this is the crucial change
Set.Data knownValues;
function register(uint value) public {
// Here, all variables of type Set.Data have// corresponding member functions.// The following function call is identical to// `Set.insert(knownValues, value)`
require(knownValues.insert(value));
}
}
It is also possible to extend elementary types in that way:
pragma solidity >=0.4.16 <0.7.0;
library Search {
function indexOf(uint[] storage self, uint value)
publicviewreturns (uint)
{
for (uint i = 0; i < self.length; i++)
if (self[i] == value) return i;
return uint(-1);
}
}
contract C {
using Search for uint[];
uint[] data;
function append(uint value) public {
data.push(value);
}
function replace(uint _old, uint _new) public {
// This performs the library function call
uint index = data.indexOf(_old);
if (index == uint(-1))
data.push(_new);
else
data[index] = _new;
}
}
Note that all library calls are actual EVM function calls. This means that if you pass memory or value types, a copy will be performed, even of the self variable. The only situation where no copy will be performed is when storage reference variables are used.
