and one more time, of course, remember all the code is available in The Foundry full course f23 of the chain Excel org or on the web3dev.education site once it's up. So here we are back in remix with our simplestorage.soul. If you skipped over the last section and want to get that contract, just come to the full repository, go down to lesson two, go over to the code in the GitHub repo associated with this course, the remix simple storage f23, and just copy and paste everything into remix yourself. To make sure you've done it correctly, be sure to hit compile. We have our simple storage contract that we created in our last lesson, which is great. It allows us to store our favorite number, and it allows us to store a list of people who have different favorite numbers, also on mapping, and some other different functionality with interacting with people's favorite number. But we want to go even further with this. We want another contract to actually deploy this simple storage contract for us and interact with it. Contracts interacting

with each other seamlessly and permissionlessly is a feature of smart contracts and blockchain development that's absolutely essential and crucial, and one of the reasons why blockchain development is so powerful. The ability for contracts to interact with each other seamlessly is something known as composability. Smart contracts are composable because they can easily interact with each other. This becomes even more important when we get to topics such as DeFi, where we can have incredibly complicated financial products and instruments interact with each other seamlessly because they're all using the same smart contract interface. So, we're going to keep our simplestorage.soul the exact same way it was from the last lesson, and we'll update it in a little bit. But let's go ahead and create a new contract called storagefactory.soul. So, let's go ahead and get this contract set up. Now, we're going to be doing this a lot, and when we work with AI pair programmers, now we're going to be doing this a lot, and when we work with AI pair programming, this is going to be a lot.

easier for us to do, but for now, repetition is the mother skill, so let's keep going. The first thing we need to do is what if you want to pause the video and add the first two things you should put at the top of every Solidity smart contract right now. Go ahead, but for those of you who didn't pause, let's go ahead and do SPDX license identifier MIT, and then let's do pragma solidity 0.8.18 or 19 or whatever you want to do. You know what, let's do 19. What do we do in simple storage? We did 18. Let's do 18. And then we'll do contracts, so this will be the third thing actually, contract storage Factory like this. And I hit command S, but you can also go and compile like so. And I'm also just going to add the caret here, meaning we're going to use 0.8.18, but any version greater than that also works as well. Awesome. Now this storage Factory contract is going to be deploying a

simple storage contract. So let's create a function that can actually deploy or create a simple storage contract. So we'll say function create simple storage contract, and we'll make this a public function. And we're going to have this create simple storage contract function deploy a contract and then save it to a state variable or a storage variable. But the question is, okay, well, how does the storage Factory know what the simple storage contract even looks like? How does this contract know about this contract? How does this contract know that this contract even exists? The first way that we could do this is we could actually go to our simplestorage.soul contract and start highlighting from the contract word and scroll all the way down to the end of the contract, copy it (command C or right-click copy), go back over to storage Factory, and below pragma solidity but above contract storage Factory, paste it in here. If we go ahead and command S or compile this, you'll see that this actually goes ahead and compiles successfully. So this is to show you that yes, right now in our storage.

factory.soul. We have contract simple storage, which ends here, and we also have contract storage Factory down here. You're allowed to have multiple contracts in the same file. Now, this isn't a best practice because we really don't want to be having multiple contracts in the same file when we can separate them out into their own files. As your projects get bigger and bigger, if you just add all of your contracts into the same file, it can get really, really confusing, really difficult to jump around the code and find the places where you want to add stuff. So normally, it's best practice to keep them separated like we did above, but we'll learn a little bit more about how to keep them separate in just a minute. If you go down to the deploy Tab and you say on the remix VM and scroll down, you actually have this section to choose your contract. We can choose either one of these contracts right now, and if on the right side you have storagefactor.soul in this contract section, you can actually choose either one, simple storage or storage.

Factory, and you can see they're both in storage factory. soul. If on the right-hand side, we go to simple storage, and we go back to this contract section, we can only choose simple storage because the simple storage contract only has one contract in it. The storage Factory has both simple storage and storage Factory, so that can get a little confusing as well if you have multiple contracts in the same file. But let's stick with this methodology for now in our storage Factory, and let's even close out simplestorage.so at the top just so we don't get confused. In our storage factory.soul, let's scroll back down to storage Factory because now that we have our simple storage in this file, we can actually deploy the simple storage contract.

Lesson 3 Part 2 | Setup - Solidity & Foundry Full Course

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