Deploying Contracts in Solidity: Simple Storage Example

The contract successfully deploys another simple storage contract using a state variable in Solidity.

### Deploying Contracts: Understanding Solidity's Simple Storage
* 📜 In this tutorial, we learn how to **deploy a simple storage contract** using Solidity, starting with the **deployment process through the interface**.
* 🚀 By clicking the deploy button, we can observe the **transaction details in the terminal**, confirming the **deployment of our storage factory**.
* 🔵 The interface provides two main buttons: a **blue view function** for simple storage and an **orange button to create a new simple storage contract**, which **executes a transaction**.
* ✅ Upon calling the create simple storage contract function, we receive a **green check mark** indicating the **successful execution of the transaction**.
* 📦 After deployment, invoking the simple storage view function reveals an **address**, confirming that the simple storage contract has been **successfully deployed** from another contract.
* 🔧 To store the deployed contract, we will declare a **state variable of type simple storage**, ensuring to maintain the **proper visibility and naming conventions** in Solidity.
* 🔍 It is crucial to note the case sensitivity in Solidity, where '**SimpleStorage**' (contract) and '**simpleStorage**' (variable) are distinct identifiers, which can sometimes lead to **confusion**.
* 💻 In our function to create the simple storage contract, we will use the **'new' keyword** to indicate the deployment of a contract, ensuring our code **compiles correctly** before proceeding to the deployment tab.

so this function is going to deploy a simple storage contract, but we're going to save it to a storage or state variable, and we're going to do it the exact same way we've been saving any variable. First thing, remember like remember how we did U and 256 public favorite number. This was in the format type visibility name. We're going to do the exact same thing. The type of a simple storage contract is going to be simple storage, and the reason that solidity is going to be able to identify this keyword is because it's the same name as contract. In the same sense that our struct keyword allows us to create a person type, the contract keyword allows you to create a new type of, well, a type of simple storage contract. So simple storage for now, we'll just give it a visibility of public, and we'll give it a variable name simple storage. Now, this is going to be a syntax you're going to see a lot, and it might be a little bit confusing the first couple times you read it. The difference between these two

is very subtle. The difference between simple storage on the left and simple storage on the right is very subtle. It's simply that the 's' is lowercased over here, and the 'S' is capitalized over here. Solidity is case-sensitive, so these are actually different words. Simple storage here is referring to the contract, simple storage here is referring to the variable. You'll often see people use the syntax when working with contracts where they name the variable the exact same as the contract itself. If this is confusing to you, you can do 'my simple storage' instead of 'simple storage' with lowercase. So either one of these works. It's good to get used to this as such, but if that's confusing you, you can do 'my simple storage'. Now in our 'create simple storage contract' function, we're going to say 'simple storage equals new simple storage' like this. This 'new' keyword is how Solidity knows to deploy a contract. So adjust this code alone. If we go to the compile tab, we compile this. This does indeed compile. We can go to deploy. We need to make sure we're on the storage.

factory.soul on the right-hand side. We'll scroll down to the contract. We can actually deploy our storage Factory like so, hitting the deploy button. And remember, you can see the transaction in the terminal here. And we can scroll down to the contract. Right now, there's two buttons. We have our blue view function, simple storage, because again, the public keyword automatically gives the variable name a getter function or a view function. And of course, we have our create simple storage contract orange button, because it is actually a transaction. Right now, simple storage returns nothing, the zero, the default value for an address, which is the zero address. And if we call create simple storage contract, we get to see a green check mark, meaning that transaction went through. Now, if we call the simple storage blue view function, we see we indeed get an address here. We have deployed our simple storage contract from another contract. Oh my goodness. So congratulations. Now you know how a contract can deploy another contract. Awesome job.

Lesson 3 Part 3 | Deploying a contract from a contract - Solidity & Foundry Full Course

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


Cyfrin Audits

The function will deploy a simple storage contract and save it to a state variable.

The contract's type is "simple storage," which Solidity recognizes due to the matching keyword.

The variable will have a public visibility and be named "simple storage.

Understanding Case Sensitivity in Solidity

In Solidity, the difference between 'simple storage' and 'Simple Storage' is subtle but significant, as the language is case-sensitive.

This means they refer to different entities: the contract and the variable.

Using the same name for both is common, but if it causes confusion, a different variable name can be used.

The 'new' keyword is used to deploy a contract in Solidity.

The storage Factory contract is deployed using a button in the interface, with transaction details visible in the terminal.

The contract has two functions: a blue view function for simple storage and an orange button for creating a new simple storage contract.

After the transaction is completed, the simple storage contract's address is retrieved, demonstrating the successful deployment from another contract.