Deploying Smart Contracts on Test Nets: A Step-by-Step Guide

Deploying a smart contract on a testnet is a significant achievement for aspiring Solidity developers.

### Successfully Deploying a Smart Contract on Sepolia Testnet
* 🚀 To deploy a smart contract, use Remix, which **automatically updates to the network** you are working with, such as the **main network** or testnets like **Gorli and Linea**.
* 💻 After deploying your contract to the Sepolia testnet, you can view the transaction on Etherscan, where you will see the **contract creation transaction** and any **subsequent interactions** with it.
* 📊 For example, after storing the number 7878 on-chain, you can retrieve it and see that the contract has **successfully updated its state**.
* 👤 When adding a person with their favorite number, such as "Pat" with 16, you will **confirm the transaction through MetaMask**, showcasing your ability to **interact with the contract**.
* 🎉 Congratulations on deploying a smart contract to a real testnet! Celebrate your achievement as you've also learned how to **send transactions to update the state of your contract**.
* 🔍 Ensure your contract compiles without errors before deploying, and remember to **switch your MetaMask to the correct testnet** and acquire the necessary **test ETH from a faucet**.
* 💡 As you progress, keep in mind the **importance of testing and auditing your contracts** before deploying them to mainnets, but enjoy the learning process with this dummy contract.
* 📱 Finally, share your success on social media to celebrate your milestones and keep yourself **motivated for the journey ahead** in becoming a proficient Solidity developer.

So now that we've added all this functionality, we're looking pretty good. We really like the way that our contract is set up. We have our favorite number, which is an internal variable, but we have a way to read it with retrieve. We have our new typing person. We have a public list of people array. We've got a public name to favorite number. I've got a way to update the favorite number, retrieve the favorite number, and add people to both our list and our mapping. Now, in the future, you'll hear me say that you should never do this before you write any tests, before you get it audited, but for now, this is just a dummy contract that we're going to deploy on a test net, so we don't really care. But let's go ahead and learn how to actually deploy this to a real testnet. This is going to simulate what deploying to a real network with real money is going to look like. Are you ready? You should be. This is going to be incredibly exciting. After you do this successfully, you should 100

tweet about it on Twitter, on LinkedIn, on Lens Protocol, on whatever social media you want. It's important to celebrate your small wins; surprisingly, it'll help motivate you moving forward. So first off, let's make sure this actually compiles. Okay, cool, we've got a green check mark. There's no warnings, there's no errors. Fantastic. Now let's go back to the deploy tab, and we'll delete this down here, and we'll scroll up, and we're going to change the environment. We're in this Remix VM, and we're actually going to move to injected provider MetaMask. Remember, this Remix VM is kind of this fake world that Remix gives to us. Injected provider MetaMask means that we're going to literally inject our MetaMask into this Remix. We're going to inject our MetaMask into this website. We're going to allow this website to interact with our MetaMask. We'll first get prompted by MetaMask to pick the account we want to use. I'm going to use account one and hit next, and we're going

to go ahead and hit connect, similar to the way we connect it to the faucet. If we scroll up to our Metamask, we now see, Oh, it says your account is not connected. That's because I'm currently on account two. Let's flip to account one, and we do indeed see that account one is connected. And now, before, where we saw kind of this fake account with fake ether, we see our actual account with the actual amount of Sepolia ETH that we have. Make sure that again, be sure to use whatever recommended testnet we have in the GitHub repo for us. We're using Sepolia. Don't worry about the rest of these for now, so make sure you're on the correct testnet to deploy to attest that you're going to need some Sepolia ETH. So, if you haven't been to the faucet, be sure to head over to the faucet to get some Sepolia ETH. Remember, you can find those in the GitHub or web3dev.education. Now, in Remix, what we're going to do, we're going to do the exact same process.

we use to deploy to the virtual remix environment. We're going to do that to deploy to the test set environment. So, we're going to go ahead and hit the deploy button, and Metamask is actually going to go ahead and pop up. This is similar to what we saw with the blockchain example with signing transactions. We're actually going to sign and send a transaction on the test set. It's similar again to us sending ether to ourselves. The difference here is though that our data section has a ton of information here. All this data is associated with sending this transaction, but this one has all this contract information encoded in machine-readable code or our compiled code in details. We can see all the payment information associated with this transaction. We can see exactly how much gas it's going to cost to deploy this contract on-chain. But again, we're on the supply test Network, so this is fake money. Anyways, to actually deploy this, we're going to go ahead and hit the confirm button, and now we're going to have sent our function. If you have the

terminal up you can see we have this call created, and it says creation of simple storage pending with this view on etherscan button. If you click the view on etherscan button, you'll get brought to this etherscan page with this transaction going through on sepolia. You'll see it's currently being indexed by etherscan, but there's a good chance it already went through. And back in remix, it actually goes ahead and gives us this green check mark saying that we did indeed deploy this contract. You might have to wait a few minutes for this to complete because, again, we're sending a transaction to a testnet blockchain, and the blockchain needs to actually reduce the block with our transaction in it. But if we wait a few minutes on etherscan, we'll eventually see a success status with block confirmations on this block section here. And exactly the same as what we saw with sending ETH to ourselves, we see all this information about the transaction: transaction hash, status, block time, from, to, blah blah, etc. But if we scroll down

this input data field is much bigger than anything we've seen before because, again, this is all the data associated with creating this contract. And, of course, we see more gas fee information because, again, deploying a smart contract to the chain is modifying the blockchain, so we have to spend gas. Now, if we come back to our remix and scroll down, we're able to see our simple storage contract, and we're able to copy the address that it's at. So, if we copy this address, we go back to etherscan, we can even paste this into the bar here, and we can see this contract that we went ahead and deployed. Etherscan is smart enough to know that this transaction created a new contract. Remember, this has to be on the Sepolia etherscan, not the mainnet etherscan, because we sent this on the Sepolia test net. So, now that we have this contract created, we have all the exact same functions that we had in our virtual environment, but these functions are actually on a test net with a contract that we actually deployed now.

we can do all the exact same things we were doing on our fake remix environment on this test environment. For example, we can call retrieve, which doesn't send a transaction, it just reads off the blockchain, and we get zero, same as what we got before. If we look up a name like Pat in name to favorite number, we get nothing back because we haven't updated anything. If we add 0 in here for a list of people, we get nothing back as well. Metamask didn't pop up here because these blue buttons are view functions. View and pure functions, like we said, don't send transactions. Now let's go ahead and actually send a transaction. Let's update the blockchain. Let's update our contract by storing a new favorite number. So let's do 7878, and we'll hit store, and we'll press this orange button. You'll see you'll get prompted with Metamask actually popping up, saying okay, let's update the blockchain, let's send this transaction. And if we go ahead and hit confirm, the exact same thing happens.

we'll get this transact to simple Storage storage transact to simplestorage.store pending view an ether scan this little check mark if we view it we can see the transaction indexing on etherscan and after you wait for a little bit the transaction will go through and now if we hit the retrieve button we can see we have now stored 7878 on chain if we copy the contract address again we paste it into sepolia etherscan we scroll down after a few minutes we'll actually see a second transaction come through we see two transactions associated with this contract the first transaction obviously is the contract creation transaction and the second transaction is us actually calling the store method etherscan is smart enough to know that this is the store method it's not always smart enough to know that but for this one it's smart enough to know and we see that we actually updated our contract and remember in the future please use these test Nets sparingly we're just starting out and we're just learning so it's okay for us to send these

transactions here though, but let's go ahead and let's keep going because name to favorite number of Pat still returns nothing. Listed people zero still returns nothing, so let's go to add person. We'll do Pat 16. We'll hit add person. Metamask pops up, obviously, because we're updating the state of our contract. We'll hit confirm. We see transact to simplestores.adperson is pending. It looks like it has succeeded. So now if we do name to favorite number of Pat, we see 16 get returned. And if we do list of people at zero, we see we get Pat whose favorite number is 16. And guess what? At this point, you've successfully deployed a smart contract to a real test net. Congratulations! You should be incredibly excited for yourself. Be sure to give yourself a pat on the back, maybe go for a walk, maybe have an extra cup of coffee or an ice cream, because additionally, you've also interacted with that contract with these buttons and remix that allow us to send transactions to update the state of our contracts.

Congratulations! You're a Solidity developer, but we've got a lot more to go. And like I said, make sure to celebrate these little wins. Celebrating little wins will motivate you and excite you to continue to move forward, so be sure to take the time to pat yourself on the back. Congratulations if you've got this far. There's a ton more for us to learn, but just you getting here is a fantastic achievement in itself. Now here, if we wanted to deploy to a different test net, all we would have to do in our MetaMask is switch to a different test net like Linea Gorilli. Since we don't have any Linea Gorilli, we actually can't deploy this to a test net. But if we used a faucet to get more Linea Corelli ETH, that's how we would deploy it. Additionally, we could do the same methodology for deploying to Ethereum mainnet or any other mainnet that you want to work with throughout this course. The difference here is obviously you just need to buy some Ethereum to

actually deploy this smart contract. Remix will automatically update to whatever network you're working with. For example, right here it says, Ah, you're working on the main network. But if we were to switch to Gorli, it would say, Ah, you're working on Gorli. But if we were to switch again, it would say, Ah, you're working on Linea. In the future, we'll learn to add different networks so you can learn how to deploy to any other EVM-compatible network that you want to.

Lesson 2 Part 9 | Deploying your contract - Solidity & Foundry Full Course

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


Cyfrin Audits

Connecting to Metamask and Deploying a Smart Contract

The user switches from account two to account one in Metamask, successfully connecting to the account with Sepolia ETH.

They are advised to use the recommended testnet from the GitHub repo and to visit the faucet for Sepolia ETH.

The user is guided through the process of deploying a smart contract with various functionalities on the testnet.

A smart contract deployment is initiated, with a pending status visible on Etherscan.

After a few minutes, the deployment is confirmed with a green check mark in Remix and a success status on Etherscan.

To deploy on a different testnet, such as Linea Gorilli, one would need to switch in MetaMask and obtain ETH from a faucet.

Deploying a Smart Contract on the Sepolia Testnet

The input data for creating the contract is extensive, with additional gas fee information due to blockchain modification.

The deployed contract's address can be copied and tracked on Etherscan, specifically on the Sepolia testnet.

The process involves transitioning from the Remix VM to using MetaMask as the injected provider for a seamless interaction with the contract.

Using a Test Environment for Blockchain Transactions

The test environment allows for the same functions as the fake remix environment, such as retrieving data from the blockchain without sending transactions.

View and pure functions do not trigger Metamask, while sending a transaction to update the blockchain prompts Metamask to pop up for confirmation.

Deploying the contract on the test network also requires signing and sending a transaction, with the data section containing important information for the deployment.

Remix automatically updates to the network you're working with, whether it's the main network, Gorli, or Linea.

After deploying the contract, you can track its transactions on Etherscan, where you'll see the contract creation and method call transactions.

By using the contract's functions, you successfully added a person and retrieved their favorite number, marking a successful deployment and interaction with the smart contract on a test net.