 Courses from Noah Hein

Ethereum is a decentralized, open-source blockchain with smart contract functionality. 

ethereum

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

Introduction to Introduction to Smart Contracts with Ethereum and Solidity

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

solidity

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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

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!

Introduction to Smart Contracts with Ethereum and Solidity

When comparing two visually similar websites, it can often be challenging to precisely identify the subtle differences between them. To facilitate a rapid analysis of these discrepancies, a practical technique involves leveraging Chrome's integrated developer tools to capture full-page screenshots of each site. Subsequently, these screenshots can be uploaded to a platform like AI Studio. There, the AI can analyze the images and generate a report detailing the variations. This entire process, leveraging a few quick shortcuts, can be completed in under a minute, delivering a comprehensive breakdown of the differences for efficient comparison and analysis.

Quickly Compare Two Sites Using AI Studio with Chrome Full Page Screenshots

It's fairly trivial to create a React project, but there's always a big hurdle between creating it locally and making it shareable so that someone else can run it. This lesson walks you through the process of automating creating a React project locally, creating the repository where it's going to be hosted, and creating shareable links where it can be run so that you can quickly and easily create single one-off demos and shoot them over to your friends and coworkers for sharing your code ideas in a working environment.


```bash
share-react-project() {
  if [[ -z "$1" ]]; then
    echo "Usage: share-react-project <project_name>"
    return 1
  fi

  local project_name="$1"
  local github_username=$(gh api /user --jq '.login')

  echo "Creating Vite project: $project_name"
  pnpm create vite "$project_name" --template react

  cd "$project_name"

  echo "Initializing Git repository"
  git init

  echo "Adding all files to Git"
  git add .

  echo "Creating initial commit"
  git commit -m "Initial commit"

  local codesandbox_link="https://codesandbox.io/p/github/${github_username}/${project_name}"

  echo "Adding CodeSandbox link to README.md"
  echo "" >> README.md
  echo "## CodeSandbox" >> README.md
  echo "[![Open in CodeSandbox](https://assets.codesandbox.io/github/button-edit-blue.svg)](${codesandbox_link})" >> README.md

  echo "Adding README.md to Git"
  git add README.md

  echo "Committing README.md changes"
  git commit -m "Add CodeSandbox link"

  echo "Creating GitHub repository: $github_username/$project_name"
  gh repo create "$github_username/$project_name" --public

  echo "Pushing to remote 'origin'"
  git push -u origin main

  echo "Project '$project_name' created successfully!"
  echo "GitHub repository: https://github.com/$github_username/$project_name"
  echo "CodeSandbox link: $codesandbox_link"
}
```

Automate Creating a Local React Project, GitHub Repository, and Live Hosted Demo in a Single Command

[Verdaccio](https://verdaccio.org/) is a fully featured NPM registry that you can run locally on your machine. It’s a great tool for testing your release process, running end-to-end tests, and simulating real-world scenarios like deploying packages, installing them, and verifying functionality as an end user would.

Nx includes a [generator](https://nx.dev/features/generate-code) that simplifies setting up Verdaccio. To configure it, run:

```shell
npx nx g @nx/js:setup-verdaccio   
```

This command installs the necessary NPM packages and creates a `project.json` file with a `local-registry` target. To start the local registry, open a new terminal window and run:

```shell
npx nx local-registry
```

This will:
- Launch the Verdaccio registry.
- Configure NPM to point to the local Verdaccio server at `http://localhost:4873`.

> **Note:** A `project.json` file provides an advanced way to define scripts, offering more flexibility than a traditional `package.json` for managing complex targets.

Setup local Verdaccio server to release NPM packages

Learn how to spin up a local NPM registry powered by Verdaccio to test deploy your NPM packages.

In TypeScript, developers often begin by defining the structure of their data using type definitions or interfaces, which is a powerful way to ensure type safety. However, as applications grow and become more complex, simply defining the shape of an object might not be enough to guarantee its consistent creation and behavior throughout the codebase. This often leads to situations where objects that are intended to be of a certain "type" might be missing crucial properties or have incorrect data, which can be difficult to track down and debug.

This lesson tackles the question of when and why to move beyond basic type definitions and embrace classes in TypeScript. It demonstrates how classes provide a more robust mechanism for defining object structure, enforcing type constraints, and ensuring consistent object creation. By establishing a clear blueprint for objects, classes not only improve compile-time type safety but also offer runtime benefits and better code organization, ultimately helping developers avoid common pitfalls associated with loosely structured objects in larger TypeScript projects.

Stop Avoiding Classes in TypeScript

Karabiner isn't only for your keyboard. It can also hijack your mouse buttons and enable them to be similar to layers on your keyboard, where holding down a mouse button can allow you to tap keys on your keyboard to trigger commands and macros that can completely revolutionize your workflows. For example, you can hold down the right mouse button and tap on R to go to references in VS Code. Or hold down the right mouse button and tap the left mouse button to chop up videos and Screenflow.

This completely unlocks a whole new world of possibilities and use cases for your mouse as you can hover your mouse over anywhere on the page. And just tapping keys on your keyboard allows you to trigger mouse actions, to trigger keyboard actions, or to trigger macros and applications and terminal commands. and anything that your imagination can come up with. 

Karabiner: Rethinking Right-Click as a Macro Command Center

Make an HTML table more readable on mobile devices by using the ::before pseudo-element. We add labels to each cell, so they appear like cards when the table is viewed on smaller screens. The ::before content is set using a data-label attribute for each cell to enhance mobile viewability without horizontal scrolling.



Create a mobile friendly table with the before pseudo-element

Learn to use CSS ::before pseudo-element for mobile-friendly HTML tables. Add labels to cells for enhanced readability on mobile, avoiding horizontal scroll.

Any app of a decent size has event flows and messages being passed around. At a certain point it becomes complicated to explain it through prose and you want to turn towards diagrams. Now setting aside the time to create diagrams that accurately describe what's happening in your codebase can be quite time consuming. Luckily, with today's AI tools, we can now just do basic walkthroughs with rough recordings over codebase dictating what's going on along the way and then upload that to tools like AI Studio and then ask it to generate diagrams in a text-based format such as Mermaid that will then generate the flowcharts and diagrams for us. So this video walks us through this process of recording a rough video, uploading it to AI Studio and then asking AI Studio to generate the proper Mermaid diagram syntax.

Generate Mermaid Flow Chart Diagrams with Gemini 2.0 from Rough Screen Recordings

I'm a diehard Karabiner user and anytime I start doing something repetitively I always move it into my Karabiner configuration. Sometimes I'll fall into scenarios where I want to trigger a command, but I also want to know if that command succeeded or failed. Since Karabiner can trigger any command, setting up the command is fairly straightforward, but knowing whether it succeeded or failed became much more difficult. Luckily for me there is a package called terminal-notifier that you can install from homebrew and you can pipe the output of your command to terminal-notifier. And have a seamless way of triggering your keyboard shortcut which runs a command and you can be notified of the results.

Use Karabiner to Trigger a Terminal Command and Get Notified of the Results

There are a lot of scenarios when inspecting a site in Chrome where you don't want any click events to fire and you don't want any scripts to run. Or maybe something is animating in and out of the page and you want to capture it at a certain moment. This is a great use case for pausing script execution, which is kind of using the debugger manually by going into the Chrome DevTools and the Sources tab and clicking the pause button to essentially pause the entire page. This will give you a chance to inspect any of the elements and styles you want to inspect. And you don't have to worry about fire and click events or anything that might interrupt your investigation into the elements and styles that you want to find.

Pause Script Execution in Chrome to Easily Inspect Elements

Gemini 2.0 has a context window of a million tokens, and this means that you can upload hundreds of files and allow it to inspect and analyze massive refactors across entire code bases. 

This lesson demonstrates concatenating an entire code base into a single file and then uploading it to AI Studio. Once within AI Studio, we ask it to find the types of tasks that it can evaluate for us. Then we select one of the tasks and ask it to generate instructions for that task. Once those instructions are complete, we then turn them over to Windsurf's Cascade agent, and we allow Windsurf's Cascade to do all of the work for us as we sit back, relax, and let the AI do our jobs.

Noah Hein

Search Results