Understanding Solidity: Functions, Variables, and EVM Compatibility

Smart contracts in Solidity compile to EVM bytecode, enabling deployment on various compatible blockchains.

### Understanding Solidity Functions and Smart Contracts
* 📜 Functions in Solidity do not modify the **state of the blockchain** and can have parameters defined in different data locations for special types like **strings, structs, and arrays**.
* 🔄 Temporary variables, defined as call data and memory, **only exist for the duration of the function call**, while storage variables are **permanent and remain in the contract**.
* 🛠 Function parameters cannot be storage variables since they are designed to **exist only during the function execution**.
* 💻 Compiling smart contracts translates Solidity code into **EVM-compatible bytecode**, which is essential for **deploying on compatible blockchains**.
* 🎉 Congratulations on completing your first contract! Remember to specify the **version of Solidity** you are using and include the **SPDX license identifier**, defaulting to **MIT** if unsure.
* 🏗 A contract in Solidity is akin to a **class in other programming languages**, with all code within **curly brackets** belonging to that contract.
* 📊 Solidity supports various data types, including **uint256, string, boolean, and int**, and allows the creation of **custom types using structs**, as well as **arrays and mappings for data organization**.
* 🌐 The Ethereum Virtual Machine (EVM) is crucial for **compiling and deploying smart contracts** on EVM-compatible blockchains like Ethereum, Polygon, and Arbitrum, so **always verify compatibility before launching**.

now I've mentioned this a couple of times, but whenever we compile this code, it compiles it down to something called the EVM or the Ethereum Virtual Machine. Don't worry too much about exactly what this means, but essentially, the EVM is a standard for how to compile and how to deploy smart contracts to a blockchain, any blockchain that is EVM compatible. You should be able to deploy Solidity code to some examples of EVM compatible blockchains and layer twos, which again, we're going to go over working with layer twos more in the future, are going to be Ethereum, Polygon, Arbitrum, Optimism, ZK Sync, and more. Just note that it's important to double-check the blockchain before you launch to it. For example, ZK Sync is EVM compatible, but a couple of keywords don't actually work with ZK Sync. Now, let's do a quick recap of everything we learned in this lesson, and then after we do this, be absolutely certain to take a break, maybe go get some ice cream, go get that extra coffee, or whatever you

like to do the first thing you want to do in any smart contract or solidity code that you write. Be sure to write the version that you want to work with and above the version. Be sure to add the spdx since identifier. If you're not sure what version to use for now, just default to MIT. Then you have to create your contract object and name your contract. A contract is similar to a class in other programming languages. Anything inside of the curly brackets for the contract is part of that contract. There are many different types in solidity like uint256, string, boolean, int, etc. If we want to create our own type in solidity, we can use what's called a struct. You can create arrays or lists in solidity. You can create mappings or dictionaries or hash tables in solidity where if you give it a key, it'll spit out the variable associated with that specific key. We can create functions in solidity that modify the state of the blockchain. We can also create functions in solidity that don't modify the state of the blockchain, view, and pure.

functions don't modify the state of the blockchain. We can also specify different data locations in our parameters of our functions, but we can only do that for special types like strings, structs, and arrays. Call data and memory mean that that variable is only temporary and will only exist for the duration of the function call. Storage variables are permanent and stay in the contract forever. Function parameters can't be storage variables since they're only going to exist for the duration of the function call. Whenever we hit compile in our smart contracts, it actually compiles our Solidity code down to EVM-compatible bytecode or machine-readable code. We'll learn more about those specifications later. And last but not least, congratulations on your first contract here.

Lesson 2 Part 10 | Recap - Solidity & Foundry Full Course

Book a smart contract audit here 👇
https://www.cyfrin.io/


Cyfrin Audits

The Role of the Ethereum Virtual Machine (EVM)

The EVM is a standard for compiling and deploying smart contracts to EVM-compatible blockchains.

Key examples of these blockchains and layer twos include Ethereum, Polygon, Arbitrum, Optimism, and ZK Sync.

It's important to double-check blockchain compatibility before launching, as some keywords may not work with certain EVM-compatible blockchains.

Basics of Writing a Smart Contract in Solidity

Start by specifying the Solidity version and adding the SPDX license identifier.

Create a contract object and define its name, with all code inside the curly brackets belonging to that contract.

Solidity offers various data types, and custom types can be created using structs, while arrays, mappings, and functions are also available for managing data and modifying the blockchain state.

Understanding Function Parameters and Data Locations in Smart Contracts

Function parameters in smart contracts can specify different data locations for special types like strings, structs, and arrays.

Call data and memory variables are temporary, while storage variables are permanent.

Function parameters cannot be storage variables, and compiling smart contracts converts Solidity code to EVM-compatible bytecode.