Solidity is an object-oriented, high-level language for implementing smart contracts.

solidity

Smart Contracts are programs stored on the blockchain that run when certain conditions are fulfilled. 

These Smart Contracts have many benefits to them such as speed, transparency, and security. The contract is immediately run as soon as the requirements are fulfilled. This creates a system where you place trust in a transparent system, instead of an opaque intermediary. 

Noah will show you how to write, test, and deploy smart contracts on Ethereum, using the popular smart contract language, Solidity. You'll also learn how to use Foundry, a popular dev-toolbelt, to streamline our whole development process. 

Throughout this course, you'll learn how to:
- safely and securely set up Smart Contracts
- write and read data on your Smart Contract
- send transactions with specific arguments to your Smart Contract
- deploy your Smart Contract using Forge and QuickNode

And more!

Artem Gromov

Welcome to Noah's course on Introduction to Smart Contracts with Ethereum and Solidity. 

Introduction to Introduction to Smart Contracts with Ethereum and Solidity

We will learn about how to install foundry, and initialize your project using the forge command line utility. 

After creating a new project, we'll learn about the high-level architecture of a forge application.

[Here is the documentation](https://book.getfoundry.sh/getting-started/installation) on how to install Foundry.

Install and Initialize a Foundry Application

Now that Foundry is installed, we can build out the functionality of our smart contract written in Solidity. We'll create various functions that allow you to increment, decrement, and read a number whose state is kept in your smart contract. 

All of the functions will have different visibility modifiers and types that constrain the behavior of your functions. We'll create our own custom error that is thrown whenever you step outside the bounds of your intended functionality.

Write a Smart Contract in Solidity

We will use the `Test.sol` smart contract that Forge provides to turn your smart contract into something that can be tested. We'll configure the file using the `setup` function and successfully run our test suite.

Set Up and Test a Smart Contract in Solidity

Here in the same file, `Contract.t.sol`, we'll test your smart contract's `increment` and `decrement` functions. We will learn about how Forge will fuzz tests and how to properly constrain the `vm` object to ensure you are testing it under the right specific conditions.

Test a Smart Contract in Solidity with Constrained and Fuzzed Inputs

Now that we tested a smart contract in solidity with fuzzed inputs, we'll move on to testing our smart contracts in an idiomatic fashion. We will delete the negative test case for the `decrement` function, and will replace it with a function that expects a specific error instead of any generic failure. The `vm` object is used to do this, and we'll pick up on the vocabulary word "cheatcode" which is a reference to the various utilities that forge provides you through the `vm` object.

[Here are more examples](https://book.getfoundry.sh/forge/cheatcodes.html) of how cheatcodes are used.

And [here is the reference sheet](https://book.getfoundry.sh/cheatcodes/) for an overview of all the available cheatcodes.

Identify Anti-patterns within Smart Contract Testing

We will start up a local blockchain that behaves like Ethereum, allowing us to test and prototype our smart contracts' behavior rapidly. It provides useful features out of the box, such as logging so we can follow the executions as they happen and pre-funded accounts with their corresponding private keys.

**Please Be Warry!** Never use or send money to the addresses on mainnet Ethereum. These keys are the same every single time. There are sure to be bots waiting to drain these wallets when funds get sent to them.

Start a Local Blockchain With Anvil

We deploy our smart contract to the local Anvil server running in the background on our machine. After we deploy the contract, we will look over some of the logging that Anvil produced for us.

Deploy Your Smart Contract to Anvil

You will learn how to inspect the Application Binary Interface — commonly referred to as ABI — of your smart contract. ABI's are generated whenever your contract is complied. It is the source of truth for how the contract expects information flowing into it to be shaped. You need the ABI to take a look at how to send transactions to and from a smart contract.

[forge book reference](https://book.getfoundry.sh/reference/forge/forge-inspect) 

Inspect Your Contract's ABI

Cast is another tool that Foundry leverages to make smart contract development easier for you. Cast will allow you to read/write data from your contracts through the terminal with minimal inputs. We'll learn how to use [cast](https://book.getfoundry.sh/reference/cast/cast) and how to read our deployed smart contract numbers.

Read Data From Your Smart Contract On Anvil using Cast

To send data, we'll use `cast send` to send a transaction that we signed with our private key to the network. We use Cast to call the `increment` function we built in a previous lesson. Then we will check Anvil to see the logs that our transaction generated.

Write Data To Your Smart Contract On Anvil using Cast

We will start off by using cast to interact with our contract that's deployed locally on Anvil. This time instead of calling `increment` we will call `decrement`. This will teach us how to interact with our smart contract whenever it expects the user to supply some data.

Send a Transaction With Arguments To Your Smart Contract On Anvil using Cast

We will [download MetaMask](https://metamask.io/), set up an account, and copy your private key for use in the next lessons. We'll also briefly learn about the structure of a browser-based non-custodial wallet. 

Non-custodial wallets are wallets where no other party holds any private information about it. This makes it very powerful — in that you have 100% control over what goes on in your wallet. But it also means you are ENTIRELY responsible. There is no do-over button, no password reset, and no support agent to help you out should you go down the wrong path. 

Install MetaMask to Use as a Test Network to Store Sensitive Information

Test Faucets are common tools in the web3/blockchain ecosystem. There are many different faucets for all of the different blockchains, and the many networks deployed on them. Faucets are a way to fund your wallet with fake/test cryptocurrency for you to play around in a low-risk environment.

Here, we'll find a Ropsten faucet and use it to add test ETH to our newly-created MetaMask wallet.

If developing with Anvil was your "dev" environment, you can think of "testnets" such as Ropsten as being a public, pseudo-staging environment.

Use Ropsten as a Test Faucet

Now that we've have our Ropsten ETH and added it our MetaMask wallet, we'll learn how to deploy our `Number` smart contract to the Ropsten testnet. We will be using the free version of [QuickNode Link](https://www.quicknode.com/) as our rcp-url. 

Deploy To Ropsten using Forge and QuickNode

We will start off with calling the `increment` and `decrement` functions on your `Number` smart contract that's deployed on the Ropsten testnet. After we've interacted with it successfully, we'll go to a website known as a "block explorer" that allows us to easily see our smart contract, and the individual transactions that we sent.

Interact With Your Smart Contract On Ropsten

Learn what NFTs are and how you can use them in a React app with Solidity.

Build a Practical NFT Ticketing Service with Solidity and React

Learn how to write, test, communicate, and interact with a smart contract using Solidity and SvelteKit.

Full Stack Web3 and Blockchain Development on Ethereum with SvelteKit

Introduction to Smart Contracts with Ethereum and Solidity

https://app.egghead.io/api/v1/lessons/ethereum-introduction-to-introduction-to-smart-contracts-with-ethereum-and-solidity/subtitles

Noah Hein: [0:00] Everyone, welcome to an introduction to Smart Contracts with Ethereum and Solidity. My name is Noah Hein, and I am going to be taking you through how you are going to write, test, and deploy your very first smart contract to the Ethereum platform.
[0:15] Given that this course is going to take about 45 minutes, that means that we are really taking you from zero to hero. We will go over to the best of our abilities, at a high level, everything that you need to know, and you will actually have a working smart contract by the time that you end this tutorial.

[0:33] That also means that there is going to be several things that you are left unequipped to deal with. And so, without further ado, we'll go ahead and hop into what foundry is because foundry is the smart contract development toolchain that we are going to be using throughout this entire course.

[0:51] Every single lesson, you will be using foundry in one way or another. Foundry manages our dependencies. It compiles our project for us and will also allow us to deploy our smart contracts to both our local machine and a test network.

[1:07] It really streamlines the entire development of writing smart contracts because instead of previous to foundry, you would have to hop back and forth between a Solidity, which is the language that we use to actually write our smart contracts. That is what gets compiled down into bytecode and that is the code that is run on the Ethereum nodes that is executing the code that you've written.

[1:31] All of that happens in Solidity. Previously, you would need to bounce back and forth between, for example, JavaScript or Python and Solidity to test your smart contracts. Foundry is the first development toolchain that has embraced Solidity as a first-class language that can be used for something that is something different than only writing smart contracts.

[1:54] It will allow us to test our smart contracts, writing the same Solidity language that we're using to write the source code that we want to test. Without further ado, let's go ahead and hop into, "How do we install foundry?"

https://app.egghead.io/api/v1/lessons/ethereum-introduction-to-introduction-to-smart-contracts-with-ethereum-and-solidity/transcript

https://app.egghead.io/api/v1/lessons/solidity-install-and-initialize-a-foundry-application/subtitles

Instructor: [0:02] Foundry, as you can see here, is considered a smart contract element toolchain, which means that it allows you to easily create workflows for writing your contracts, deploying them, and testing them.
[0:18] To install Foundry, you can go to the Get Started tab. They will have different commands for all of the different platforms. For me, since I am on Mac, we can just copy this command. Then, we can go over here and paste it. That will install it.

[0:34] Then, what we want to do is we can run foundry up to install our project. Then, wherever you want to create your project, you can run forge init. I will call our project forge egghead. Here, you can see that forge has created a scaffold project for us.

[1:02] What we will be really working on is out of the source and the test folders. Source is where your smart contracts will go. You can see here that this is just an empty smart contract that needs to be filled out with functionality.

[1:17] Then, there's a test contract that inherits the test contract that forge gives us, along with some other nice functionality for writing tests that we will dig into.

[1:28] There's also this lib folder that we will not be making use of in this course, but is worth digging into as you level up in your smart contract writing skills.

[1:38] Whenever you import third-party libraries for various bits of functionality into forge, they will go in your lib folder, and you will import them in your smart contracts through there.

https://app.egghead.io/api/v1/lessons/solidity-install-and-initialize-a-foundry-application/transcript

https://app.egghead.io/api/v1/lessons/solidity-write-a-smart-contract-in-solidity/subtitles

Noah Hein: [0:02] To begin, we will open up our Contract.sol file in our src folder. The first thing that you'll notice is this very first line is a comment. SPDX-License-Identifier is just what software license you would like your program to use. We will be keeping this as unlicensed, since we are not planning to publish this.
[0:23] On our first line of code, you can see that we're declaring our Solidity compiler's version with pragma solidity. We're saying that we are going to grab a version greater than .8.13. Then we're declaring a contract whose name is Contract.

[0:40] Let's go ahead. We will change contract to the Number. Then we will declare a private variable of type uint. We will call that num. There's no value here. We are just creating the variable that we will assign a value to via the constructor. Our constructor will take another uint argument, and we will call this _num, and we will just set num = _num. This constructor will run whenever this contract is deployed and then never again.

[1:28] The next thing that we want to make is a mutator function, we will call this increment(), and we will need to give it a visibility modifier of public, which means that anything or anyone has access to this. Anyone will be able to increment our private variable called num through this public function. We will just set num += 1.

[1:58] Next thing that we'll do is another function, and this will be decrement(). This will again be a public function. However, we also want for this one to take an argument of _num. You can see this underscore syntax that we've used both in the decrement and in the constructor is not necessary but is considered best practice whenever you are manipulating a variable that is contained within your smart contract.

[2:29] Since we are manipulating num, if you are going through a smart contract and you see this underscore, there should be a variable that doesn't have the prefix attached, that its state is kept in the smart contract itself. For decrement, we will then call num and then we will take away whatever the value of _num is.

[2:59] The last thing that we're going to do is create a reader function because currently we have no way to read the value. Since this is a private variable, we do not have access to it. For this reader function we will again make this a public.

[3:16] There is another modifier, and this is called view, and view means that no state is going to change in this contract. It will throw a compiler error if you attempt to change state in the contents of a view labeled function. Since we're going to be returning something, we need to declare the return type as well. It will be returns(uint). You can see here we can just return num.

[3:55] Awesome. This is the entirety of the smart contract that we will be using. However, and you may notice that this on line 16 is potentially a bug since everything in this contract is of type uint. We are taking any number an arbitrary argument and taking it away from num. There is potential for underflow errors to occur here.

[4:22] We want to account for that. We will create a custom error, and we will call it UnsafeDecrement(). Here, what we can do is we will just wrap this in an if statement. We could say if ( num - _num ) > , then we can go ahead and safely deduct the parameter num from our value of num.

[4:51] If it wouldn't be greater than zero, then we don't want to do it. What we will do here is we will just call else, and we will use the keyword revert, which will abort the execution of this function and it will revert any state that had changed. We will say revert UnsafeDecrement and that will throw this custom error that we established earlier.

[5:16] Now we can know that this will always be safe to do so, and it will throw an error should we perform a dangerous or unsafe decrement.

https://app.egghead.io/api/v1/lessons/solidity-write-a-smart-contract-in-solidity/transcript

https://app.egghead.io/api/v1/lessons/solidity-set-up-and-test-a-smart-contract-in-solidity/subtitles

Instructor: [0:02] Here you can see that we're in our test folder. We're looking in Contract.t.sol. You can see it looks just like our other smart contract file where we declared the Solidity version.
[0:17] Here you can see that we are importing the Test.sol smart contract, which we are inheriting on our contract test by using is Test. This contract test has all the functionality that the Forge Standard Library provides through this test smart contract.

[0:36] Here you can see it has a function called setUp(). SetUp is run once at the beginning of each test suite. You can do any configuration that you need in this setUp function. To get that setUp, we're going to need to import our Contract.sol file. Then what we can do is with that imported, we can say that we've got a number contract, and we're going to put that in the variable number.

[1:08] Then in the setUp, we can say that number is equal to a new number and will declare 10 as the beginning variable there or the beginning value for our smart contract.

[1:20] Now you can see if we run our file here, we save it, and then we open up a terminal, we run forge test, that everything is still running, and we've got an OK. You can see that we've got this test example, it will go through Forge, will go through every single function, and if it has a test prefix, it will test it and it will expect an assertion to be true here.

[1:48] We can go ahead and quickly check to make sure that everything is still working by making that fail. Now you can see that our test suite will fail.

[1:57] With that, we can delete this test example function, and we'll go ahead and create a new function called testIcrement(), and testIcrement should be a public function. For this, what we want to do is we want to call the getNum because we want to track that. We'll do number.getNum() and will store that in that contract number variable and then we can call number.increment.

[2:27] Now we can expect there to be a difference here between number.getNum(), because that should return 11 now, and contract.num will be 10.

[2:36] We can see if we do assertEq(). This will take two parameters and compare the two. We'll say we would expect contractNum +1 = number.getNum. We can go ahead and run that, make sure that all of this is working. We run forge test. You could see we are getting a passing test result.

https://app.egghead.io/api/v1/lessons/solidity-set-up-and-test-a-smart-contract-in-solidity/transcript

https://app.egghead.io/api/v1/lessons/solidity-test-a-smart-contract-in-solidity-with-constrained-and-fuzzed-inputs/subtitles

Noah Hein: [0:01] The next thing that we'll want to do is we'll want to test the decrement. We can just copy a lot of this. We'll call this testDecrement.
[0:16] Here, we will want to pass in a number since that's how our other decrement works. It takes an argument. We'll call this a number of type unsigned integer. We'll call this getNum. Then we will call the decrement, so we'll do number.decrement. Then we will call getNum right there. Here we can see if we do - num should be number.getNum.

[0:55] We would expect this to work. However, whenever we run forge test, you can see that this doesn't work. You can see that the reason is we're getting an unsafe decrement right here and that is not great.

[1:14] It does mean that our error is working, this unsafe decrement error is happening whenever we call a number. Why did that happen? You can see whenever Forge sees that you have put in a parameter for one of your functions, it will fuzz it for you.

[1:32] If you're not familiar with what fuzzing is, it just means that it is going to throw a bunch of different numbers into this function, and it's going to run it each time, and it's going to expect all of them to pass. You can see that it obviously did a number that was larger than 10 that would have caused some integer underflow, and so it reverted it but that means our test failed.

[1:56] In order to combat this, we have the ability to constrain the fuzzing numbers, and so we can call the VM -- is the virtual machine and it allows you to modify the runtime. We can say vm.assume, and we want to assume that our number is going to be smaller than whatever number.getNum is.

[2:24] Now, whenever we run this test, you'll see that all of the numbers will be small enough, and we won't run into that error again. Here, if we run forge test, let's go ahead and make that bigger. You could see, cool, we are getting two OKs.

[2:41] It's good to be able to test that if we made any breaking changes. We want to have a negative test as well to make sure that "Hey, this is still failing whenever this vm.assume isn't there." What we'll do is we'll turn this comparison sign. We will flip it on its head. We want to say, "Hey, the number is always going to be larger than whatever our current value is."

[3:10] If we do this, we should see that our test suite fails. Awesome. You can see our testDecrement is bad. It also is complaining that we have the same thing twice. You would see that it fails for the same reason that the other one did. Aside from the different names, we want to do this testFail. If you add this Fail right here, Forge will expect the assertion to fail.

[3:38] Here, if we run this and we do forge test, you can see that all of our things are passing. With that, we don't need to assert equality here because we are never getting to this line. This number.decrement is always going to be throwing an error. We can remove that. See, the forge test is still running. All of them are passing.

https://app.egghead.io/api/v1/lessons/solidity-test-a-smart-contract-in-solidity-with-constrained-and-fuzzed-inputs/transcript

https://app.egghead.io/api/v1/lessons/solidity-identify-anti-patterns-within-smart-contract-testing/subtitles

Noah Hein: [0:01] This is good, but it's not great to test that your contract isn't working. We would like to get a little bit more specific because it's good to know that it's not working, but you want to know why it isn't working.
[0:16] I would say, generally, that this test fail is a bit of an anti-pattern. You're not always able to exactly pin down why it's failing, so this is a stopgap solution.

[0:26] What you really want to be doing is test. Cannot is typically the word that you would use. Cannot doesn't have any actual value. It's still just a regular test that's going to expect something to be true. We'll say testCannotDecrementLargerNumbers(). Here we'll again uint num, and it will be a public contract.

[0:54] Here it's going to be these exact three lines again. What we want to do is we have this assumption here, but the VM has a lot of what Forge calls cheat codes. What we can do is we can expect it to revert. What this will do is it will say, "Hey, we expect the very next thing to cause something to revert." It will also say, "Hey, what do we expect that revert to be?"

[1:28] Here, we'll leave this blank to see what runs. If we open this up, we can see that if we run for each test, we can see that failed and, which one failed? It looks like the last one did. The test cannot decrement larger numbers. We'll go ahead and copy this and we'll dig into this a little bit.

[1:50] We'll do Forge test, and we'll pass a flag here. You can do -vvvv and this will add a debugger or tracer to it. Then since we don't want to make things too noisy, we'll do --match-test and then we'll pass in our test right here.

[2:08] Here, you can see that it only ran the one test, and we also attached a debugger here. You can see that we ran our setup successfully. Cool. Then on this test, we got the number. It was 10. We made an assumption, and then we did another getNum.

[2:24] Then, whenever we did the expectRevert, you can see the actual error here. It was an arithmetic under/overflow. Here you can see that the reason went from our custom error to this. This arithmetic under/overflow is really what's happening under the hood a little bit.

[2:48] What we want to do is we have access to that class of error. We'll say stdError. We'll call this an arithmeticError. Now, we can see that whenever this passes or whenever we run our test, again, you could see that it passes, but it's giving us some warnings about our unused variables because we're not using the contractNum here.

[3:18] We don't need to use that. We can assume that the number is going to be larger. Then, we can know that this is going to revert. We don't even want to do all of that. We want to test the entire suite right here. Whenever we run forge test, you could see that all of our things are passing.

[3:41] Here, the only other one, you can see that it's also saying that we are not using this. Like I said, this is a bit of an anti-pattern so we will remove that test entirely. Now, whenever we have an entire passing test suite with no warnings and no errors, we know that our contract is both incrementing and decrementing and having a specific error that gets thrown whenever the decrement happens.

https://app.egghead.io/api/v1/lessons/solidity-identify-anti-patterns-within-smart-contract-testing/transcript

https://app.egghead.io/api/v1/lessons/ethereum-start-a-local-blockchain-with-anvil/subtitles

Noah Hein: [0:00] To deploy our contract, we are going to use the Anvil tool. Anvil is one of the other CLI tools that we installed whenever we originally ran that foundryup command. Up to this point, we have only been using Forge.
[0:16] Anvil will create a local blockchain on our computer. To create that service that will run in the background, all we're going to type is anvil. Anvil listens on port 8545, if it's available, and then shows you a bunch of configuration options that we started with. It shows you what our base fee is and then the gas price as well as the gas limit.

[0:44] Here you can see Welcome to Anvil. This is the really good stuff that Anvil gets you, is it prefunds you 10 different accounts, all of which have 10,000 ETH to spend on your fake local blockchain, along with all of the private keys.

https://app.egghead.io/api/v1/lessons/ethereum-start-a-local-blockchain-with-anvil/transcript

https://app.egghead.io/api/v1/lessons/solidity-deploy-your-smart-contract-to-anvil/subtitles

Noah Hein: [0:00] To deploy our smart contract, we are going to use Forge. Forge will deploy our contract on to our Anvil server that's running in the background.
[0:09] To do that, we're going to do forge c. C is shorthand for create. Then we're going to need to pass in the private key that we copied over here, so make sure you have this copied. You can do forge c, and you will pass in the path to your contract. We'll do src/Contract.sol and then a colon and the name of the contract that you want to deploy.

[0:40] You can only deploy one contract at a time using forge create. If you had multiple smart contracts within your Solidity file, you need to suffix it with this colon and then the name of the contract.

[0:55] After that, you need to give it a private key. This private key will be signing the traction, that is deploying this contract up to our chain. We'll be paying all of the gas fees that are associated with that.

[1:09] The other thing that we'll need to do is since our contract has a constructor, here you can see that we've got this constructor. That is not optional. We do need to pass that. That's another flag. We'll say -constructor-args and we'll pass 10 as the value.

[1:32] Awesome. You can see that we successfully deployed our contract. You can see that the deployer was the private key that we passed in. If you take a look here, you can see that our private key was f2ff80. Over here you can see that it is f2ff80. It's the same private key. That private key matches to this deployer, which is like the public key that matches our private key.

[2:14] You can see here that we used this to sign it, but it winds up being this b92266. It's what you see on chain. You can see a little bit of your private key and public key, and how they relate to each other there. Then, you can see that our contract was deployed to this address.

[2:35] It also gives us the transaction hash. You can see all this happening over here on Anvil. You can see that when we originally booted it up. There it is. You can see it runs a bunch of different commands here. Then it finally runs an eth_sendRawTransaction. You can see this transaction matches the same hash over here. You see it ends in 27b. Here you can see it ends in 27b as well.

[3:02] This is the contract that was created along with the block hash and everything. You can see that it is now successfully deployed up to the chain. We can begin interacting with it.

https://app.egghead.io/api/v1/lessons/solidity-deploy-your-smart-contract-to-anvil/transcript

https://app.egghead.io/api/v1/lessons/solidity-inspect-your-contract-s-abi/subtitles

Instructor: [0:01] To interact with our newly deployed smart contract, we will use another tool that we installed from Foundry, which is Cast. In order to use Cast, we need to know the shape of the contract that we are going to be interacting with. We need to get what's called the ABI from our smart contract.
[0:21] An ABI stands for Application Binary Interface. In the same way that you interact with APIs, an ABI is the same idea, but for a smart contract instead of a particular programming interface.

[0:36] To get the ABI for our smart contract, we use Forge. Forge has an inspect tool that lets you get various information for any particular contract. We can use forge inspect Number. It knows to look in source and then go through the contracts to find the particular contract that you have.

[0:56] We will forge inspect Number. Then it takes another argument. In our case, we want the ABI.

[1:04] There's many different options that you can pass here. You can look in the Forge book to find an exhaustive reference list of all of the different options that forge inspect has.

[1:15] You can see here it spits out a big blob. This is essentially our contract in a program. You can see here it's a big JSON blob. It has a list of inputs. You can see here that we have the name _num as uint256. Here you can see the type that it is. In this case, this is our constructor that we're looking at in this particular input right here.

[1:43] This gives us all of the information that we need to actually start sending transactions to and from our local chain.

https://app.egghead.io/api/v1/lessons/solidity-inspect-your-contract-s-abi/transcript

https://app.egghead.io/api/v1/lessons/solidity-read-data-from-your-smart-contract-on-anvil-using-cast/subtitles

Instructor: [0:00] Here, what we're going to want to call is we will use getNum(). We will copy that. We can go ahead and clear that out. We'll use cast call. Cast call, for the first argument, it will take the contract that we're interacting with. We can hop back over to Anvil and grab "This is our contract." We can cast call on here. Then we can do "getNum()".
[0:34] Here you can see that it returns a hexadecimal number. If you plug this into a converter, this a represents 10. That reads successfully from our smart contract. You can see here that whenever you go back to Anvil, nothing changed, no state changed here. You can see if we run this again, it does that.

[1:02] All that it does is it just runs eth_chainId and eth_call, which are both read operations. No actual state is changing on chain. Normally, this is something that Anvil is giving you. You wouldn't see any of these read operations performed in the explorer. This is the client logging out events for us so that we can see what is happening under the hood here.

https://app.egghead.io/api/v1/lessons/solidity-read-data-from-your-smart-contract-on-anvil-using-cast/transcript

https://app.egghead.io/api/v1/lessons/solidity-write-data-to-your-smart-contract-on-anvil-using-cast/subtitles

Noah Hein: [0:01] If we want to change state on the chain, and we want to send a transaction, that will increase our contract's state. In this case, we're going to change it from 10 to 11.
[0:14] We're going to call the increment. We'll go back over here, and we'll do cast send. Cast send takes a different parameter here. Instead of getNum, we're going to want to go back to our ABI. We'll open up another window, and we'll do that again.

[0:33] We'll forge inspect <Number> abi. Here we can see that this is decrement. Let's grab wherever our increment is, so here. That's increment. What we will do is we will say instead of getNum, increment. Since we are sending something up onto the chain, we are going to need to pass it a private key. We can go back to Anvil. Again, we can grab this private key.

[1:12] To show you that this is totally permissionless, we'll grab something else. This would replicate or simulate someone else interacting with the smart contract that you deployed up onto the chain. We'll do private-key. Then, we will send that.

[1:29] Awesome. Here, you can see that we got 1 back. We got a new blockHash. You can see now that our blockNumber has incremented to 2. You can see from our original deployment, the blockNumber was 1.

[1:45] Unlike the regular blockchain that is constantly moving forward the blockNumbers, Anvil isn't unnecessarily using your CPU. It will only "mine" a transaction whenever you send something. If you go back over to your Anvil server, you will see that "Hey, there is a new transaction. We have a new blockNumber."

[2:06] We'll call that one more time to just show, "Hey, cool, all of this is working." You can see that the blockNumber increments to 3. Awesome. It looks like those transactions are going through. Let's call getNum again. If you read hexadecimal, you can see that this would now map to 12. You can see that a was 10. Then, b would have been 11. Now, c is 12.

https://app.egghead.io/api/v1/lessons/solidity-write-data-to-your-smart-contract-on-anvil-using-cast/transcript

https://app.egghead.io/api/v1/lessons/solidity-send-a-transaction-with-arguments-to-your-smart-contract-on-anvil-using-cast/subtitles

Instructor: [0:00] Now we can try what it looks like to call the decrement function. That would be relatively the same thing. Instead of increment, we're going to want to decrement this. The difference here is that while increment doesn't take any arguments, decrement does.
[0:22] Here we can do decrement. Then here, we can pass in 2. You can see that doesn't look quite right. You can see that that didn't work. We can't just pass in directly here. What actually cast wants us to do is it wants us to put in the data type that we're expecting here. We're going to pass in uint256. Then, right after that, it will take all of your arguments.

[0:53] If you had multiple arguments, you would then space them out appropriately. Since we just have the one, we'll say, "Hey, we want to decrement this." You can see, cool, that works. Our block number increased. Now we would expect our getNum to return 9.

[1:10] We'll double-check that. You can see that, cool, we are now getting 9 back on our getNum. That's what it looks like to interact with your smart contract on your local testnet.

https://app.egghead.io/api/v1/lessons/solidity-send-a-transaction-with-arguments-to-your-smart-contract-on-anvil-using-cast/transcript

https://app.egghead.io/api/v1/lessons/solidity-install-metamask-to-use-as-a-test-network-to-store-sensitive-information/subtitles

Instructor: [0:00] For the next step, you'll want to actually deploy this to a test network. In order to do that, we're going to want to generate some private keys. Once you start doing that, it really helps to have an app that does and holds a lot of this information for you and makes it easy to grab.
[0:20] To do that, we use MetaMask. You'll want to go to metamask.io. Then you can go to download. You can either download it for Chrome, iOS, or Android. They also have Firefox and Edge as well. This MetaMask is a browser extension. Here you can see that it will bring you to a interface that looks very similar to this.

[0:47] You will want to setup your MetaMask account, and we'll walk through a simple installation. It will give you a couple of key pieces of information. The most important of which is going to be your seed phrase.

[1:01] Your seed phrase is a multiword long between 12 and 24 is usually the amounts. It is a 12-word long seed phrase. This seed phrase is the most important aspect of security whenever you are dealing with crypto wallets.

[1:22] Your seed phrase will be used to recover your wallet if you forget your password for here, or if you wanted to generate all of these accounts somewhere else, you would also use your seed phrase for that. Your seed phrase is like the source of truth for all the different accounts that you have.

[1:41] For all of these, you can see that you can have many accounts attached. For all of these different accounts that I have, all of these use the same seed phrase. Here, you can see here's one. It generated. Here's the public key for this account.

[2:00] If I go to this account, and I go to settings...Actually, I don't want to go to settings. I want to go to account details. You look at the account details. Here's account three. We'll call this Egghead test. Awesome. We see that this is our public key. You could scan this QR code. It would show you a public key as well.

[2:26] If you want to export your private key, you can generate multiple accounts. They can all have different public keys and private keys public. All of those are connected to your seed phrase. You don't want to share that ever for any reason. You want to write it down. You don't want to put it in an email. You want to write it down somewhere safe and put that in there.

[2:54] Here, you can see that I'm showing you this private key because I don't care if you know this private key. What I care about is that you know my seed phrase so I won't be showing you that. I know that I may be going a little bit hard on this. Never share your private keys or your seed phrase with anyone for any reason unless you want to give them all of your money permanently.

[3:18] You cannot change your seed phrase. You cannot reset your private key password. It's a very different paradigm than you may be used to like for email or something. This is very, very important. I want to stress this to you.

[3:30] I don't want you to be a victim of sharing this to some scammer that convinced you that like, "Hey, I need this particular piece of information." There is no reason that anyone ever needs your private key or your seed phrase to help you out.

[3:45] With this private key, we have this. Now, we have a nice key management solution that will live here.

https://app.egghead.io/api/v1/lessons/solidity-install-metamask-to-use-as-a-test-network-to-store-sensitive-information/transcript

https://app.egghead.io/api/v1/lessons/solidity-use-ropsten-as-a-test-faucet/subtitles

Instructor: [0:01] Now what we can do is we can get some test funds for our testnet. Here we can look up Ethereum testnet faucets. Here we can go to Ropsten. There are multiple testnets, and Ethereum is always changing. There will be different testnets that come and go and are supported as the protocol changes over time, but I like Ropsten.
[0:30] We'll go to the very first Ropsten faucet here. We'll give it our address. Over here, we can click on this, and we're on our Egghead Test account. Let's copy that to the keyboard. We can Give me Ropsten ETH. Cool. We successfully queued this.

[0:46] You can see it expects it to get it within half an hour. We can actually take a look here. We can change this from Ethereum Mainnet. There are many different options here, but we can go to the Ropsten test network here.

[1:04] Looks like we got five Ropsten ETH on this little account right here. It looks like it gave us a little bit more. Maybe I used this account in a previous demo. I'm not quite sure. We have 4.6 Ropsten ETH. Fantastic.

https://app.egghead.io/api/v1/lessons/solidity-use-ropsten-as-a-test-faucet/transcript

https://app.egghead.io/api/v1/lessons/solidity-deploy-to-ropsten-using-forge-and-quicknode/subtitles

Instructor: [0:01] With that, we can now deploy our contract to the Ropsten test network. Instead of taking a look on our local machine to look at state, we will go to a block explorer. What we'll want to do is we'll want to go back over here. With us on this test network, we can do the exact same steps that we did before.
[0:25] The first thing that we'll want to do is we'll scroll up to whenever we ran our forge create. We'll need to change the private key here. The private key, we will want to grab this from MetaMask. We can go back to our window here, and we will click on here.

[0:50] We can go to Account Details, export our private key, type in your password, and click. Let's go ahead and copy this. Our private key here, paste that in, and our constructor args will say 10. Then, there's another argument. We're going to shut down our Anvil server here since we don't need it anymore, and we're going to pass in an RPC URL flag.

[1:22] Since we are not running an Ethereum server on our local machine, we will need to go grab an RPC from somewhere. There are a lot of different services that provide RPC access. I use QuickNode. You can go to quicknode.com and sign up for an account. It just asks for your email. From there, you can go to the dashboard here and we'll create an endpoint.

[1:46] Here, we're on Ethereum and we want to grab the Ropsten endpoint since that's where we got all of our Ethereum. Over here, we don't want to have any add-ons. Cool. Here is a free plan and discover. Here, we will create that.

[2:11] Now, all we need right here is this HTTP provider, so we can grab that, and we can just paste it right there. Then, whenever we hit this, you can see that this will begin compiling.

[2:29] Don't be worried if this takes a little bit longer than it did previously because now instead of waiting for our own machine to pick up what, "Hey, we sent a transaction, and it immediately mines it for us," we need to wait for the Ropsten test network to receive the transaction and deploy it.

[2:47] Here you can see that this is our public key on MetaMask. If you double-checked this against the account that you created on MetaMask, you would see that this is your public address. We can see that we deployed it here, and there's a transaction hash. We'll look this up in a little bit.

https://app.egghead.io/api/v1/lessons/solidity-deploy-to-ropsten-using-forge-and-quicknode/transcript

https://app.egghead.io/api/v1/lessons/solidity-interact-with-your-smart-contract-on-ropsten/subtitles

Noah Hein: [0:00] We can actually see here the same calls that we were making. Instead of cast call on this contract address, we will use this Deployed to address instead. Here we can delete all of this and run that. You can see the same deal here. We need to provide the --rpc-url of this guy right here and pass that in. Cool. We can see that we are getting that base of 10 again.
[0:40] Again, if instead of cast call, if we do cast send, then we have our --rpc-url here, but we're also going to want to put in our private key again. Instead of getNum(), let's do increment like we did before and then our private key.

[1:07] We will go grab our private key from MetaMask, or we just have it up here, so we can copy that and paste that in, and we can run that. Again, this will probably take a little bit longer than before because we're sending that up to the network and waiting for it to confirm our transaction. Fantastic.

[1:30] You can see, hey, cool, look that it deployed this and here you can see that our blockNumber is much, much higher than on our local test network, but it does the blockHash and it mines the transaction, everything. That's cool.

[1:43] Let's do one more so that we can make sure that all of this is working how we expect it to. We did our increment successfully. Let's just change this back to decrement and then we'll add the parameter as well. Let's change this to decrement. Then uint256 and then we will decrement it by 3. Awesome, cool.

[2:11] Now, we're going to use what's called a block explorer to go take a look at all of these. I'll just grab this transaction hash from this most recent transaction. We'll go over here and etherscan is by far the most popular one.

[2:24] We'll say etherscan.io and we want to be not on Ethereum Mainnet. We want to go to the Ropsten TestNet. Block explorers let you look at everything, all of the activity that's happening on any particular blockchain on a particular network. You can see that it shows you here, here are some of the most recent blocks, and the most recent transactions where you can look it up.

[2:48] If I paste in my transaction hash here. You can see, hey, cool, does pop up. You can see that it came from us. Again, if we take a look here at MetaMask, we can see that we have this E9FC and look at that ends in e9fc as well.

[3:08] You can verify that, "Hey, this is indeed that we have been interacting with this particular smart contract." We know that it's us. It's from us, but what is it to? It's to this particular contract. Here, you can see this actual thing. It looks like, cool, that we uploaded this four minutes ago. This was our contract creation whenever we deployed it. Then, we incremented it, and we decremented it.

[3:32] Here, you can take a look at the contract. You can see this is the published ByteCode that's up and living on the chain. You can see that the methods it's getting based on the input data. Very cool. This is an overview of what it looks like to deploy a smart contract and interact with things on chain.

[3:58] You can see this is the exact same scenario that you would have on Mainnet for example. It was done. It wouldn't be quite so easy to get all the money, but you can see on any of these transaction hashes that hey, cool, if we increment that, that we did that.

[4:15] You could see how much our transaction fee was. We used .00007 or 3 Gwey was the GAS price at the time. It gets you some block along with how many block confirmations, which is, you can see right here, the number of blocks that has been mined since, along with the transaction hash. That tells you, "Hey, look, this was on Ropsten. No actual money was changing hands here."

[4:45] Awesome. From here, you have successfully deployed a smart contract and incremented it and decremented it. You may also notice here that you don't see that read operation deployed on here because that didn't change any state.

[5:00] All of the people that are running Ethereum nodes on the Ropsten didn't need to record that you read it. They took the request, and they gave you the information, but it doesn't need to stay there because a lot of bloat on the chains. They already have a lot of information that they have to log.

[5:16] They don't write any of the read operations that you do. That's only whenever you're changing state that you'll see these transaction hashes come up. You have now successfully deployed a contract to a test network and interacted with it. Congratulations.

https://app.egghead.io/api/v1/lessons/solidity-interact-with-your-smart-contract-on-ropsten/transcript

Introduction to Smart Contracts with Ethereum and Solidity

Noah Hein

Free Community Resource

You might also like these resources:

Build a Practical NFT Ticketing Service with Solidity and React

Full Stack Web3 and Blockchain Development on Ethereum with SvelteKit

Credits

Free Community Resource

Course Content

You might also like these resources:

Build a Practical NFT Ticketing Service with Solidity and React

Full Stack Web3 and Blockchain Development on Ethereum with SvelteKit