🎥 Beacon Chain Validator Leaderboard
A video that shows how you can get Ethereum Beacon chain data like the Beacon chain smart contract data and validator balances.
A video that shows how you can get Ethereum Beacon chain data like the Beacon chain smart contract data and validator balances.
A video that covers the changes/additions made to the Ethereum network with the Shanghai upgrade.
In this video, learn about various Ethereum staking options along with their pros and cons.
Learn more about the Trace and Debug APIs of Ethereum and how they can be used to track internal transaction with the help of transaction traces.
An informative video on enhancing NFTs value and attracting interest to your NFTs.
Learn how to send a transaction on Ethereum using Ethers.js v5 and v6.
Learn how to run your own Ethereum validator. The video covers selecting and configuring the hardware and staking ETH.
A video showing how to use Etherscan to its full potential by showcasing various platform features.
A video explaining the best practices of creating an NFT business model with a template.
A video explaining the best tech stack to deploy your NFT project.
Learn how to set up a QuickAlert for ENS Domain registrations and get notified via email with the help of Pipedream.
Learn how to create a Discord bot that sends messages about NFT transfers on the Ethereum blockchain using QuickAlerts.
Learn how to create an NFT Collection using AI to generate the images, Foundry to deploy the contract, and IPFS for decentralized storage.
This quick guide gives a deep dive into everything you need to know about reentrancy manipulation.
This comprehensive guide explains what Web3 wallets are, the different types available (non-custodial, custodial, and smart contract), and which type may fit best for different needs. It also lists popular Web3 wallets, such as MetaMask, MyEtherWallet, Trust Wallet, Coinbase Wallet, Binance Wallet, Gnosis Safe, and Argent, and offers tips on how to keep wallets secure, including education on keeping your Web3 safe.
This guide on Account Abstraction is Part 1 of a two-part series covering ERC-4337, where we'll delve into its technical aspects and functionality.
This guide on Account Abstraction covers part two of a two-part series covering ERC-4337, where we will delve into implementing and testing an ERC-4337 compatible smart contract.
This guide will cover EIP-4844 (Proto-Danksharding) and how it will benefit Ethereum and other layer 2 rollup solutions.
Learn the basics of upgradeable smart contracts and how to implement them in this introductory guide.
In this guide, we’ll see an overview of how smart contracts work on the Ethereum blockchain. This will include how to set up an Ethereum IDE and then the process of writing and deploying a smart contract.
In this guide, we will understand the basics of blockchain in a simple and non-technical way with the help of analogies, examples and also show the impact blockchain as a technology can have on society.
In this guide, you will learn the fundamental concepts of blockchains, such as accounts, transactions, blocks, cryptography, and more. By the end of the guide, you will have a foundational understanding of the inner workings of blockchains.
This guide will show you how to build a multi-chain NFT analytics app.
In this advanced guide, you'll learn how to use Dapp Tools to create, test, and deploy a basic Escrow smart contract on the Sepolia testnet.
Esta guía cubrirá la parte de creación y lanzamiento de nuestro propio ERC-721 (NFT) usando una librería de smart contract 0xcert/ethereum-erc721
This guide will walk you through how to develop a REST API that interfaces with the Compound Finance protocol.
In this guide, you will learn the different ways to verify your smart contract source code using Etherscan, Remix.IDE, Hardhat, Brownie, and Foundry.
This guide will give you an in-depth walkthrough of how to estimate gas price using pending transactions in Python.
This guide will teach you about the two different types of nodes on Ethereum and explore the requirements needed to run them.
This guide covers an overview of Ethereum testnets, specifically Goerli and Sepolia, their differences, and how Ethereum developers use them for testing and experimentation. The article also provides information on creating an Ethereum Sepolia endpoint with QuickNode.
In this guide, you will add to your existing knowledge of the Ethereum Virtual Machine (EVM) by exploring its various components and learning how it executes opcodes to update the world state of Ethereum.
This guide will describe what the Ethereum Mempool is and demonstrate how to access and query it with QuickNode.
In this guide, you will learn the basics of airdropping NFTs to users. This will include creating and deploying your own airdrop-compatible smart contract using OpenZeppelin and Foundry.
In this guide, you will learn how to deploy a ERC-20 permit contract (using the EIP-2612 standard) and approve token transfers without spending gas.
In this guide, we will show you how to implement a one-click MetaMask login using Web3.js and a PHP backend.
This guide provides step-by-step instructions on how to build a Web3 frontend using React, wagmi, and Bootstrap. The guide will walk you through the process of connecting a wallet to your frontend and displaying account information, such as the connected wallet address, account balance (in Ether), and chain ID.
In this guide, you will learn how to build an ERC20 token balance app with the QuickNode SDK.
This guide will show you how to build an ERC20 token balance app with the QuickNode Token API.
In this guide, we will learn how to build an Ethereum dApp that will store short versions of URLs.
In this guide, we will show you how to retrieve all the NFTs from a particular collection and demonstrate how to display them on our frontend using QuickNode's NFT API, React, Ethers.js, and TailwindCSS.
This tutorial will look at how to use Hardhat and Ethers.js, which are now becoming the standard in building smart contracts. We will create, run, compile and deploy smart contracts made using the Hardhat Ethereum development environment.
This guide will teach you how to deploy a smart contract on the Ethereum Goerli network and interact with other smart contracts. By the end of this tutorial, you will have a hands-on understanding of the deployment process and how to send transactions to interact with other smart contracts.
In this guide, we will show you how to connect to the Ethereum network using Go.
In this guide, we'll cover installing Ethers.js, use it to connect to a web3 provider, and get the latest block height.
In this guide, we will show you how to install Web3.js, establish a connection with a provider, and retrieve the most recent block number from the Ethereum blockchain.
In this guide, let’s see how we can connect to Ethereum using .NET and Nethereum.
In this guide, we’ll cover how to connect to Ethereum with PHP using the web3.php library.
In this guide, we will learn how to connect to the Ethereum blockchain using Java and Web3j.
In this guide, we will connect to the Ethereum network using Python and Web3.py.
In this guide, we will learn how to connect to the Ethereum network using a Ruby gem (or package) called eth.rb.
In this guide, you will build a simple React user interface where a user can connect to MetaMask and display their wallet balance and address.
In this short guide, you will gain an understanding of smart contracts and deploy your first Hello World smart contract to an Ethereum testnet blockchain (Goerli).
This guide will walk you through creating a basic block explorer to help you start your journey of becoming a blockchain data expert.
In this guide, we will learn how to create a dutch auction smart contract which will make the entire auction process trustless.
In this short guide, you will learn how to implement the factory contract pattern.
In this guide, you will learn about Soulbound tokens and why they are useful. You will also learn how to deploy a Soulbound token contract on Sepolia using Hardhat.
This guide teaches how to create and deploy a staking vault smart contract using the ApeWorX (ape) framework on Ethereum. It covers setting up an Ape project, writing ERC-20 and ERC-4626 vault contracts in Vyper, testing the contracts, and deploying them to the Sepolia testnet.
In this guide, you will learn how to create a Web3 Chrome Extension that can fetch the Ether balance of an address.
In this guide, you will learn how to create an EVM Token Factory dApp to allow users to create their own ERC-20 token in a couple of clicks.
The Graph is a powerful tool that allows developers to index, query, and retrieve data from blockchains efficiently. This technical guide aims to provide a comprehensive, step-by-step tutorial on creating a custom Subgraph using The Graph. By following this guide, developers will learn how to define schemas, map data models, deploy a Subgraph, and interact with it to fetch relevant information from the blockchain.
In this guide, we’ll create a Hello World smart contract and deploy it using Hardhat via QuickNode.
In this guide, you will learn how ERC-6551 can provide new capabilities with your digital assets and demonstrate how to create and deploy your own Token Bound Account (ERC-6551) using Hardhat and OpenZeppelin.
In this guide, we will learn about the ERC1155 token standard and how to create an ERC1155 token.
This guide will show you how to create and deploy an ERC-721 token.
This guide will bring you up to speed with ERC-777 tokens and show you how to create, test and deploy them using Foundry.
This guide will bring you up to speed with ERC-20 tokens and show you how to create them.
This guide details the process of creating and deploying an ERC-404 token, showcasing the smart contract creation process, testing, and deployment techniques specific to Ethereum (and other EVM chains). It aims to equip developers with the skills needed to launch their own ERC-404 smart contract effectively.
This guide will show you how to create and deploy an upgradeable ERC20 token using OpenZeppelin and Foundry.
In this guide,we will demonstrate exactly how this is done by creating and deploying an upgradeable smart contract from scratch using OpenZeppelin and Hardhat.
In this guide, you will learn how to create a blog website using HTML/CSS/JavaScript and then learn how to serve your website on IPFS using QuickNode.
This guide will demonstrate how to create Hooks on Uniswap V4 using Foundry and the uniswap-v4 hook template.
In this guide, you will learn how to create your own DAO using Aragon.
In this guide, we will understand/learn how to set up our own Oracle inside a smart contract.
This guide, we will learn about Brownie, a Python-based tool used to write and deploy smart contracts.
This guide will take a deep dive into understanding the difference between custodial and non-custodial wallets and how to make a non-custodial transaction using QuickNode.
In this guide, we will learn about gzip compression and how to enable gzip on RPC calls in JavaScript using the Ethers.js library.
In this guide, we are going to learn how to fetch Ethereum event logs in Ruby using the Eth.rb library.
In this guide, we will demonstrate the different ways in which you can retrieve transaction history on Ethereum.
This guide will teach you how to retrieve and filter Mempool transactions on Ethereum using a WebSocket connection and JavaScript.
In this guide, let’s go through the process of forking the Ethereum Mainnet at an older block and impersonating an account using Foundry.
In this guide, we’ll cover how to fork Ethereum Blockchain with Ganache.
In this guide, let’s go through the process of forking the Ethereum Mainnet at an older block.
In this guide, we will cover creating an Ethereum address in Go using the Go-Ethereum Client library.
In this guide, we will cover creating an Ethereum address in JavaScript using Ethers.js.
In this guide, we will see how we can generate a new Ethereum address in PHP.
In this guide, we will cover creating an Ethereum address in Python using the Web3Py library.
This guide will cover creating an Ethereum address in Ruby using the ruby-eth gem/package.
This guide will teach you how to use QuickNode's Blockbook add-on to create detailed transaction reports for an Ethereum address, covering all its transactions, including standard transfers and ERC-20 token activities, within a time period you define.
Learn how to get notified via SMS for USDC Token Transfers on the Ethereum blockchain using QuickAlerts.
This guide will show you how to obtain a wallet's current balance of a particular ERC-20 token.
This guide will teach you how to set up and run a Geth node on the Ethereum blockchain.
This guide will teach you how to run a Prysm Beacon node, a Golang implementation of the Ethereum Consensus specification developed by Prysmatic Labs.
In this guide, you will learn how to interact with smart contracts using blockchain explorers (i.e., Etherscan) and Web3 libraries (i.e., Ethers.js, Web3.js)
This guide will walk you through how to interact with Uniswap smart contracts using a JavaScript library called ethers.js and Uniswap’s JavaScript SDK.
In this guide, we will learn how to lazy mint an NFT using Rarepress.
In this guide, you will be introduced to QuickNode's `qn_getTransactionReceiptsByAddress` API method and how it can be used to retrieve multiple transaction receipts by a given address.
This guide will give you an overview of Aave as well as flash loans and walk you through how to create a flash loan smart contract in Solidity.
This guide will provide step-by-step instructions on creating batch requests on the Ethereum network. You will learn what batch requests are and how to make a script for batch requests using Node.js. Note that this guide only applies to users running their own Ethereum node locally or on a remote server.
In this guide, you will learn how to manage your WebSocket connection on your Ethereum node endpoint to properly handle downtime and disconnects.
In this guide, we will demonstrate two ways in which you can mint an NFT on thirdweb - through the thirdweb dashboard (with no code!) and then using thirdweb's SDK with TypeScript.
In this guide, you will learn how to optimize your Ethereum RPC usage by leveraging the native Multicall integration with Viem to perform batch contract reads and multiple state-changing calls efficiently.
In this guide, we'll go over all of the terminology and information around sending a transaction on Ethereum and re-sending the same transaction using Ethers.js on one of the Ethereum test networks.
In this guide, we will learn more about ENS and How to resolve ENS domains using JavaScript library web3.js and QuickNode.
This guide will explain what Hyperledger Besu is and cover the requirements and steps needed to run a Hyperledger Besu node.
This guide will walk you through how to run a Keeper bot, an entity that bids on several types of assets based on how their value fluctuates as part of the ecosystem to maintain a stable value for DAI.
This guide will teach you how to set up and run a Nethermind node on the Ethereum blockchain.
This guide will give an overview of Trade Butler bots and walk you through how to run one locally with Ethereum.
This guide will give an overview of OpenEthereum and cover how to run an OpenEthereum (ex-parity client) node on various operating systems.
This guide will walk you through how to run a Expedition Block Explorer for the Ethereum blockchain.
Learn how to send a transaction on Ethereum and other EVM-compatible blockchains using the Viem library.
In this guide, we will learn how to send an EIP-1559 transaction using Ethers.js.
This comprehensive guide covers the steps to send ERC-20 tokens on the Ethereum blockchain using the QuickNode SDK with JavaScript.
This comprehensive guide covers the steps to send ERC-20 tokens on the Ethereum blockchain using Web3.py with Python.
In this guide, you will learn how to send transactions with EIP-1559 and Legacy Methods on Ethereum using Python and web3.py library.
This guide will walk you through the steps of setting up a custom RPC provider in Brave Wallet, allowing you to access dApps quickly with QuickNode.
In this guide, you will learn how to integrate QuickNode with Coinbase Wallet and how QuickNode is playing a significant role in shaping web3.
This guide will walk you through the steps of setting up a custom RPC provider in MetaMask, allowing you to access dApps quickly with QuickNode.
This guide will walk you through the steps of setting up a custom RPC provider in Rabby Wallet, allowing you to access dApps quickly with QuickNode.
This guide will teach you how to set up a Chainlink node and connect it to the Ethereum network. By the end of this tutorial, you will have a working Chainlink node that can be used to provide data to smart contracts on the Ethereum network.
This guide will show you how to create a local development environment for Solidity
In this guide, you will discover how to store data on IPFS using either QuickNode's IPFS tool or by setting up your own IPFS node. You'll then deploy a smart contract to Ethereum Sepolia's testnet to store this data's unique hash and finally design a frontend to render and interact with the hash stored within your smart contract.
In this guide, we will learn how to stream pending transactions from Ethereum and similar chains with Ethers.js.
This guide will demonstrate how to swap tokens on Uniswap V2 using JavaScript and the Ethers.js library. The technical demonstration will include a code walk-through and an example of a token swap from ETH to DAI on Ethereum mainnet.
This guide will demonstrate how to swap tokens on Uniswap V3 using the Uniswap SDK and Ethers.js
In this guide, we'll walk you through building a wallet performance analyzer app using Syve's DEX Price Data & Wallet Tracking APIs. This application allows users to enter a wallet address and analyze trading performance metrics, such as profit and loss, for each token traded.
In this guide, we will teach you more about Chainlink VRF and how it works.
In this guide, you will delve into the world of DeFi and learn about The Vault Standard (ERC-4626), which simplifies the process of interacting with different DeFi protocols and creating yield-generating vaults. You will understand the functioning of yield-bearing vaults, explore the ERC-4626 Tokenized Vault Standard, and even develop your own yield-bearing vault using Remix.IDE.
In this guide, we will teach you about the Keccak256 hash function and its use within Solidity smart contracts on Ethereum.
This guide will demonstrate how to interact with smart contracts with Laika and QuickNode.
In this guide, we will talk about the Single Flight add-on on the QuickNode Marketplace and show you how to use it to make your development more efficient.
In this guide, you will learn about reactive development and how to use Subspace with QuickNode.
This guide goes over a 73-point checklist to help you never write a bad NFT smart contract again.
In this guide we will show you Solidity's lesser-known cousin Vyper. We will walk through what Vyper is, why you may want to use it, and how to deploy a smart contract written in Vyper to an Ethereum testnet.
In this article, we will talk about Solidity and smart contracts, What they are and what role they actually play in the ethereum development with the end goal of writing a smart contract using Solidity.
In this article, you will learn how to create an Ethereum smart contract using Vyper.
In this article, you will learn how to build a sample app in Svelte, and connect it to a smart contract that we deploy on the Sepolia Network.
This guide will demonstrate how to interact with the 0x API, specifically how to get the best price quote for a pair of tokens using Javascript.
This guide presents Etherflow, a visual tool for composing Ethereum Virtual Machine (EVM) RPC calls. It shows how to use Etherflow for making simple, intuitive RPC calls to the Ethereum blockchain.
This guide will cover on-chain and off-chain Ethereum scaling solutions and take a deep dive into Rollups.
Foundry is a powerful, developer-friendly platform for creating and deploying smart contracts on the Ethereum blockchain. This guide offers a comprehensive introduction to the Foundry framework, helping you get started with developing your own decentralized applications.
In this guide, we will learn how to set up and use Scaffold-ETH.
This guide will show you how to look up all NFTs for a given address on Ethereum Mainnet using QuickNode's NFT API. It provides an easy-to-follow tutorial for developers to retrieve information about NFTs and use it in their projects.
In this guide, we will teach you about the Pending and Queued state of transactions on the Ethereum network. We will also demonstrate how to request data programmatically with Python and Web3.py, using our handy QuickNode endpoints as the infrastructure to communicate with the Ethereum network.
In this guide, you will learn how to predict smart contract addresses before deployment using Hardhat, OpenZeppelin, and Solidity.
This guide explores the concept of stealth addresses within blockchains, specifically focusing on Ethereum's ERC-5564 proposal, addressing the privacy concerns in transaction visibility. It will delve into the technicalities of this solution and demonstrate its application through Umbra Cash, offering a practical perspective on enhancing transaction privacy.
This guide will teach you all about common vulnerabilities in Solidity. You'll first solidify your understanding of smart contract security in theory, then examine specific Solidity vulnerabilities and how to fix them to keep your smart contracts safe.
In this guide, you will learn what the Diamond standard is and how it works.
In this guide, you will learn how to create, deploy, and test an EIP-2535 compliant Diamond smart contract using the diamond-1-hardhat repository and louper.dev, which is a tool for inspecting diamond smart contracts on EVM-based chains.
In this guide, you will learn more about the web3 developer stack and the tech included.
This guide will teach you how to decode transaction calldata so you can better comprehend other transactions you come across. By the end of the guide, you’ll also learn how to encode and decode programmatically with Web3.py and Python.
In this guide, we'll teach you about Streams and then demonstrate how to stream real-time blockchain data to a React app using an Express.js HTTP API, socket.io, Web3.js and tailwind.
In this guide, you will learn more about accounts on Ethereum, diving into both Externally Owned Accounts (EOA) and Smart Contract Accounts (SCA).
This guide will cover the idea of transactions in the context of the Ethereum network.
In this guide, you will learn more about replay attacks and how they affect users on Ethereum today.
This guide will provide step-by-step instructions on how to properly manage your Ethereum addresse's nonce when sending transactions.
In this guide, let us understand what the ABI of smart contracts is.
This guide offers a concise overview of the Ethereum Attestation Service (EAS) and shows you how to create and verify attestations yourself.
In this guide, you will learn what Ethereum is, how it works, and how to use it.
In this guide, you will learn about a new Decentralized Social Media Platform, Farcaster, and how to build your own Farcaster Frame using TypeScript, Express.js and your own Hubble node (optional).
In this guide, we will delve into the concepts of Maximal Extractable Value (MEV) and discuss its risks, importance, and how it plays a role in blockchains today. Later, we'll show you how to use QuickNode and the Merkle.io MEV Protection add-on to protect your transactions from potential MEV risks.
In this guide, we will take a detailed look at the EVM to learn what the EVM is and how it operates.
In this technical guide, we will cover everything you need to know about Yul, the intermediate language for Ethereum virtual machines.