Gas Optimization Techniques in Solidity Contracts

Optimizing gas efficiency in Solidity contracts can significantly reduce deployment costs.

### Optimizing Solidity Contracts: Gas Efficiency Techniques
* 🔧 In this tutorial, we focus on enhancing the professionalism of a Solidity contract by **optimizing certain variables for gas efficiency**.
* 📉 The owner and minimum USD variables are set once and can be optimized using the `constant` and `immutable` keywords, which help **reduce gas costs significantly**.
* ⚙ The initial deployment of the contract costs approximately **859,000 gas**, and through optimization techniques, we aim to **lower this figure**.
* 💰 By implementing the `constant` keyword for the minimum USD variable, we saved **nearly 19,000 gas**, showcasing the **importance of these optimizations**.
* 📝 When defining constant variables, it’s a common practice to use **uppercase naming conventions**, such as **MIN_USD**, to improve readability and indicate their nature.
* 🌐 On expensive chains like Ethereum, the gas savings from using constant variables can translate to **significant monetary savings**, demonstrating the practical benefits of these optimizations.
* 🚀 As you progress in your Solidity learning journey, remember that while **gas efficiency is important**, it should not be your primary concern when starting out; focus on **writing functional code first**.
* 🔍 Additionally, the `immutable` keyword can be applied to variables like owner, which, when set once in the constructor, also contributes to **gas savings** similar to the **constant keyword**.

we're going to modify this contract to make it a little bit more professional. It's not going to be end-to-end amazing, but it's going to be a little bit better, and you'll see why in a minute. So the first thing that we're going to do is

we're looking, we're going to look at some of these variables here, in particular, owner and minimum USD. Owner gets set one time in our contract here and then it never changes again. Minimum USD gets set one time, even outside of the Constructor, if we have variables

that only get set one time, we can actually use some tools and Solidity to make them more gas efficient. For now, let's compile our FundMe contract and then deploy it to a JavaScript virtual machine. Remember, we can go ahead and deploy it right now, however, funding and

withdrawing and doing any of the money stuff isn't going to work because, again, we don't have a Chainlink Network on our JavaScript VM, so those aren't going to work so well. But for what we're going to do right now, we don't really care so

much. Here's what we do care about, you do care about how much gas this costs to actually send. We do care about how much gas this costs to create. Right now, creating this contract costs about 859,000 gas, and we're going to add a couple

of tricks right now to bring this number down. We're going to add some stuff back in in a bit which will bring it back up, but for now, we're going to learn some tricks to bring this number down. The two tricks that we're going to learn are the

constant keyword and the immutable keyword in their solidity there are two keywords that make it so that your variables can't be changed and those keywords are constant and immutable you can learn more about them in the solidity documentation if you assign a variable once outside of a function and

then never change it so if if it's assigned at compile time you can go ahead and add this constant keyword we'll learn later about storage but when you add a constant keyword this minimum USD no longer takes up a storage spot and is much easier to read to so now we

recompile this and we deploy this new contract let's see if we saved any gas if you look in the transaction logs now we can grab the transaction cost of how much this costs to deploy let's compare it to how much it was before wow we saved almost 19 000 gas that's

almost as much gas as it cost to send ethereum typically constant variables have a different naming convention typically you'll want to do them all caps like MIN_USD so all caps with underscores so now let's just find minimum USD and replace that with all caps as well with this interaction

we know that this variable is a constant variable and it's much cheaper to read from now if we go ahead compile this and redeploy in our fund me contract even though this is a view function remember view functions do have gas costs when when called by a contract as a constant

variable we can see the execution cost of this variable 21 415 gas so let's put a little note right underneath it if we remove the constant variable we delete this contract we redeploy click fund me we hit minimum USD again we can now see how much gas this was

cost if it wasn't a constant variable. We can see the gas cost did indeed go up. Now, on chains that are much cheaper, this gas difference probably won't make that much of a difference, but on more expensive chains like Ethereum, this is going to make a big difference for

example, on Ethereum, we can actually see current gas prices on Ethereum here. We see the current gas price of Ethereum is about 141 gwei. So, we'll go to our converter right away. We'll copy the gwei price times this, we'll get the gas price of calling our minimum USD, which is this

number here, which if we put back in our Ethereum unit converter, we can see it costs this much gas. And if we times that by the approximate current price of Ethereum, which is around three thousand dollars, calling minimum USD as a constant is going to cost nine dollars, probably is.

That is, at a non-constant, is going to cost almost an entire dollar more. You, you can see how all these little gas optimization tricks are going to make your life a lot better. So, let's keep this constant keyword in here. We'll learn more about constant and storage in

later sections of this course. Now, as you're just getting started with this course and with Solidity, do not struggle and do not worry about making your contracts as gas efficient as possible in the beginning, and especially right now, just write your contracts as best as you can. Once you get really good at gas

and once you get much later on in the course and much more advanced with Solidity, then you can start going back and working on gas optimizations, but do not let gas optimizations hold you back or if you start stressing over it, just let it go. Don't worry about it, and just

Write your code as best you can. So, long story short, do not stress about gas optimizations right now. Now, another variable we only set one time is going to be our owner variable. Owner equals message.sender. We set this one time in the constructor. Variables that we set

one time, but outside of the same line that they're declared, and we set them for example in the constructor, we can mark as immutable. Typically a good convention for marking immutable variables is going to be doing I underscore so that we know that these are immutable variables. They have very

similar gas savings to the constant keyword. Owner, of course, is a variable that we can't set on the line here because inside the global scope, there's no function going on. However, inside functions, because inside the global scope there's going to be no message.sender. There's only going to be

a message.sender when we're inside of a function. So, inside here, we might say I owner equals msg.sender and then, of course, we'll scroll down and we'll change this require only owner now equals I owner. Now, if we compile that and deploy it,

we can see how much gas we can see how much gas calling I owner is going to be by with the immutableness. We get 21 508, which we'll go ahead and copy for now and we'll put right here. We'll say

immutable. Now, if we remove the immutable keyword, let's close this, redeploy. Now, if we scroll down to I owner, scroll up the logs, we go down to the call, scroll down, we see the execution cost was much more. So, we'll do go backslash, paste that.

in here, gas or non-immutable, so you want to keep some of these tricks in mind when it comes to storing variables. The reason that these two save gas is because instead of storing these variables inside of a storage slot, we actually store them directly into the bytecode of the

contract. And like I said, don't worry too much about that for now. Later on in the course, we'll teach you more about storage and a lot of this low-level stuff that comes with these contracts, but for now, just know that these exist and they're nice gas savers if you're

Lesson 4 Part 22 | Advanced: Immutables & Constants - Solidity & Foundry Full Course

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


Cyfrin Audits

Contract Modification for Professionalism and Gas Efficiency

Modifying the contract to improve professionalism.

Analyzing variables 'owner' and 'minimum USD' for gas optimization.

Compiling and deploying the FundMe contract to a JavaScript virtual machine.

Functionality limitations due to the absence of a Chainlink Network.

Initial deployment cost is approximately 859,000 gas.

Gas Optimization Techniques: `constant` and `immutable` Keywords

Introduction to `constant` and `immutable` keywords for gas efficiency.

Using `constant` keyword for 'minimum USD' variable reduces gas consumption.

Significant gas savings (almost 19,000 gas) observed after using `constant`.

Naming convention for constant variables (all caps with underscores).

Gas cost analysis of view functions with constant variables.

Recommendation to focus on gas optimization later in the learning process.

Gas Optimization: `immutable` Keyword and Owner Variable

Optimizing the 'owner' variable using the `immutable` keyword.

Naming convention for immutable variables (I_).

Explanation of `message.sender` context within functions.

Gas cost comparison with and without the `immutable` keyword.

Explanation of how `constant` and `immutable` variables save gas.

Advice to prioritize code functionality over gas optimization initially.