Learn Ethereum, Rails and Realm

Web3 is a paradigm shift in how applications are interacted with, ran, and built. 

It’s not just a Pump-and-Dump scheme on cryptocurrencies or Bored Ape NFT profile pictures you can put on Twitter.

A fundamental tenet of Web3 is bringing ownership back to the user. You no longer have to trust that your data is being properly handled on someone else’s server (although, currently Web3 ecosystem mainly depends on centralized infrastructure such as GitHub).  

This ownership is achieved through blockchain, cryptocurrencies, NFTs, and smart contracts.

A great example of this type of ownership is through how you exchange money in Web3. There is no intermediary like Stripe, or PayPal to process your transactions. You can even build your own smart contracts that receive crypto (e.g. Ethereum or ‘eth’ for short) and then process that eth how you’d like.

Building this type of smart contract is exactly what Matías is going to show you how to do right now.

Matías builds out a Web3 application that allows you to receive tips in the form of eth in a tip jar on your website. This means your application will be backed by a smart contract that’s accepts eth, stores data, and emits Solidity events.

The frontend application uses SvelteKit which you’ll see how easy it is to get up and be productive with in minutes. A huge benefit here is that the JavaScript you write is just that, JavaScript. You’ll be able to take what you learn and implement it into any framework of your choosing.

While you build this application you will learn how to:

- Write a smart contract using Solidity language
- Test the smart contract using just JavaScript through the waffle framework
- Communicate and interact with the smart contract using ethers.js in a SvelteKit application
- Deploy your smart contract to make it public and accessible to anyone

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

solidity

Full Stack Web3 and Blockchain Development on Ethereum with SvelteKit

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Build an NFT Based Ticketing System

Rails is a web-application framework that includes everything needed to create database-backed web applications according to the Model-View-Controller (MVC) pattern.

rails

Expanding on [Part 1](https://egghead.io/lessons/angularjs-rails-todo-api-part-1), this lesson will look at how to bootstrap AngularJS in a rails application as part of the asset pipeline. With Angular available, you'll see how to communicate with the Rails API using $resource.

Rails Todo API Part 2

AngularJS is an open-source JavaScript framework, maintained by Google, that assists with running single-page applications. Its goal is to augment web-based applications with model–view–controller (MVC) capability, in an effort to make both development and testing easier.

angularjs

Rails makes an excellent choice for delivering data to AngularJS via REST apis. In this first lesson of a two part series, you'll see how to create a simple API for CRUD operations on TODOs using Rails. This isn't an introduction to Rails, and assumes you know the basics. 

Rails Todo API Part 1

Create a search directive with AngularJS and Rails. You'll want to take a look at the related [Rails TODO API Part 1](https://egghead.io/lessons/angularjs-rails-todo-api-part-1) and [Rails TODO API Part 2](https://egghead.io/lessons/angularjs-rails-todo-api-part-2). This is **not** a Rails how-to, so some knowledge there is expected to get up and running.

Search Directive with Rails

Learn how to test ActiveRecord named scopes using RSpec.

In this lesson, we will test a `User` model that will have a `by_ci_email` method 
that we will define on the model. We will test this method in our `user_spec.rb` file and pass in a lower case email argument to demonstrate that the `by_ci_email` method is functioning correctly by finding the correct user.

Test ActiveRecord Named Scopes

Learn how to test ActiveRecord validations using RSpec.

In this lesson we'll write a test that expects the `name` attribute to be present on the User model instance. We'll see that at first this test fails because we need to add this validation on the model.

Test ActiveRecord Validations

Learn how to test custom ActiveRecord validations using RSpec.

In this lesson we'll write a test that expects the `email` to be found on the `invitations` table. We'll see that at first this test fails because we need to add the custom validation on the user model. Once we implement the validation and create the `InvitedValidator`, the test will pass.

Test Custom ActiveRecord Validations

If you make a mistake when naming your database column, and have data that you want to keep unchanged. You can use the change method with the rename_column definition in your migrations files to update a single column name in your database.

Rename A Database Column with Ruby on Rails Active Record Migrations

If you want to give the users the ability to follow or become friends with each other. Rails lets you create a join table in your database and have it reference the user database table. 

You can use Active Record to associate the new table with User table by using the `class_name` method

Create Active Record Self-Referential Relationships In Ruby on Rails

When you create a User model with Devise using the command `rails generate devise User`. Devise will create  default columns in the database for your User model. To add your own columns for your users you can create a new Rails migration and add any columns you want for your users.

Add Custom Fields to a Devise User Model with a Ruby on Rails Migration

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

ethereum

ERC-721 is the Non-Fungible Token (NFT) standard that implements an API for tokens inside of Smart Contracts. 

Luckily, the OpenZeppelin library makes it easy to enforce this standard with the `ERC721URIStorage` class! We just import the `ERC721URIStorage` class and specify that our contract is an instance of it. Then, set the return type in our constructor to `ERC721`.

Create an ERC-721 Token with OpenZeppelin

We need our users to be able to mint their NFT tickets. We also need to limit the number of available tickets. 

Start by making sure each NFT has a unique ID. OpenZeppelin gives us the handy utility `Counters` for this. We will increment the ID each time an NFT is minted. 

Once your NFTs have IDs you can use the inherited `_safeMint` function from OpenZeppelin in your `mint` function to mint an NFT for the initiator of the function. Also, make sure to increment the ID and decrement the number of remaining NFTs.

Add a Mint Function to Your NFT Smart Contract

Let’s add an image to our SVG. We’ll start by creating a base 64 encoded SVG using `Base64` and `OpenZeppelin`. 

Then, in order to actually associate an image to our token, we’ll have to apply it to our token’s metadata. We’ll create a base64 JSON object that includes our image, save it as a string variable that lives in memory, then call the `_setTokenURI` method with our NFT’s ID and our metadata string.

Add an Image to an NFT with Token Metadata

We want to actually sell our NFT tickets, so let’s set a mint price. 

In our smart contract, we can just set the price to an integer variable. We’ll then make our mint function `payable`. When a function is payable in Solidity it means it can receive ether. 

Once our mint function is payable, we can call the `require` function to check if the initiator of the function is sending enough ether.

Set a Mint Price on Your NFT Smart Contract

Right now our sale can be open and closed by anyone. We want to take ownership of our smart contract to prevent this.

We'll use `Ownable` from OpenZeppelin, Set the `openSale` and `closeSale` public functions to `onlyOwner`, and then set the owner of the smart contract in the deploy script.

Restrict Smart Contract Functions to a Specified Owner

So far we’ve been deploying to a blockchain running locally. Let’s get our smart contract onto the Rinkeby test network. 

Create an account on the command line and then get some ether through a faucet. In this lesson, we used [https://faucets.chain.link/rinkeby](https://faucets.chain.link/rinkeby) to get our fake ether. Then we use our same deploy script, except with the `--network` flag that we set to `rinkeby`.

Deploy a Smart Contract to the Rinkeby Testnet

Let’s create a dApp that connect to a smart contract on the Rinkeby test network! 

I’ve created a starter repo ****for you. Just run `git clone git@github.com:ryancharris/nftix-demo-ui.git`. Then just run `yarn` and add the smart contract’s address to an ENV file.

Set Up a React dApp From a Starter

We need a way for our user’s MetaMask wallets to connect to our dApp. We can accomplish this with the `ethereum` object that MetaMask injects into the browser’s `window`. 

When the user connects we’ll save their wallet address as state using the `useState` hook.

Support MetaMask Connections to a React dApp

Users should also be given the option to disconnect their wallet from your dApp.

There isn’t a programatic way to accomplish this, but we can remove their wallet address from state, adjust the UI, and use `react-router` to navigate them to root in order to provide a clear UX.

Disconnect MetaMask from a React dApp

Since we are storing the user’s wallet address in React state, it is lost when the dApp is reloaded. To fix this, we’ll cache the address in localStorage. 

We’ll use the `useEffect` hook to look for an address in localStorage if there isn’t one in local state.

Cache a MetaMask Wallet Address in localStorage

SolidStart is a JavaScript Framework designed to build full-stack SolidJS apps and enhance your developer experience.

In this course, you will learn how to:
- Set up a SolidStart project
- Toggle different rendering modes
- Leverage file system routing to turn your files into routes
- Create API routes to expose some public endpoints
- Fetch, prefetch, update and cache your data
- Turn your functions and actions into server-executing ones
- Get rid of unnecessary network waterfalls by using Single Flight Mutations.

After this course, you should be able to leverage SolidStart to build your Solid applications.

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

SolidStart is a JavaScript Framework designed to build full-stack SolidJS apps and enhance your developer experience.

In this course, you will learn how to:
- Set up a SolidStart project
- Toggle different rendering modes
- Leverage file system routing to turn your files into routes
- Create API routes to expose some public endpoints
- Fetch, prefetch, update and cache your data
- Turn your functions and actions into server-executing ones
- Get rid of unnecessary network waterfalls by using Single Flight Mutations.

Getting Started with SolidStart

Bootstrap is an incredibly popular CSS framework designed to make your website look great on mobile and desktop.

By the end of this course, you'll be familiar with many of the popular classes and components that Bootstrap uses to apply in your own projects.

For each feature you build in the course, you'll get a sense for what the relevant classes do for those components and links to documentation for further exploration.

For the course demo application, we will analyze the landing pages of Microsoft and Apple to identify common components that are implemented. When these are identified, you'll implement these components yourself with Bootstrap.

You'll build several common UI elements such as a nav bar, a carousel of images, Cards, and Forms.

Through building these components, you'll understand what is behind the different classes Bootstrap gives you and get familiar with how it exposes flex and grid layout for you.

Cascading Style Sheets bring order and beauty to our applications.

Create Professional Responsive Websites using Bootstrap

This course is perfect for those looking for a lightweight alternative to NgRx Store that scales effortlessly.

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

Scalable Signals Angular Architecture with NGRX Signal Store

Learn how the latest JavaScript features can help you improve your codebase. 

Learn the Latest ECMAScript Features (ES2024, ES2023, ...)

course repository: https://github.com/ducin/egghead-typescript/tree/brand-types-value-objects

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

Domain Data Modelling using TypeScript Aliases, Brand Types and Value Objects

**Note:** This course is being actively developed and more lessons will be added in the future.

Cursor is an AI-enhnaced code editor that allows you to call upon the robots to refactor or stub out functions for you with natural language. 

In this course, John will show you workflows that will save you time and effort by utilizing the features such as its mult-line editing and context.

In particular, by giving Cursor's AI the proper context, whether that's lines of code or multiple files, you'll get better output when trying to extend or refactor logic that's present.


Bite-size video tutorials for badass web developers.

egghead

Productive Developer Workflows with AI Enhanced Cursor IDE

Learn the fundamentals of React Query by going through the basic API and then implementing search in an employee tracking app.

Simplify State Management with React Query

Vue (pronounced /vjuː/, like view) is a progressive framework for building user interfaces. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable. The core library is focused on the view layer only, and is very easy to pick up and integrate with other libraries or existing projects. On the other hand, Vue is also perfectly capable of powering sophisticated Single-Page Applications when used in combination with modern tooling and supporting libraries.

Create Interactive 3D Experiences with TresJS

You've seen that Angular signals are here, and know that signal-components are coming up.

This marks a paradigm-shift towards reactive programming in Angular.

Are you ready?

What if you could start learning signals and feel pleased with your progress? And reach a point where you feel confident when using signals in production?

And feel ready when signal-based components come?

Changes are coming, and you can get ahead of them.

By taking this cousre you will learn how to:

- Create computed signals
- Share your signals in services
- Use and cleanup signal effects
- Turn signals into observables and vice versa
- ... and more

In 52 minutes over the course of 20 bite-sized lessons, you'll learn everything you need to know to take advantage of signals now and be prepared for signal-based components!

angular

Modernize State Management in Angular with Signals

Get started with Supabase on your machine

Supabase is an open source Firebase alternative. A service to:

- Listen to database changes.
- Query your tables, including filtering, pagination, and deeply nested relationships (like GraphQL).
- Create, update, and delete rows.
- Manage your users and their permissions.
- Interact with your database using a simple UI.

Supabase is not a 1-to-1 mapping of Firebase. Most notably, Supabase uses Postgres rather than a NoSQL store. 

Search

Search Results