Forem: Paul McAviney

Get Started on Celo with Infura RPC Endpoints

Paul McAviney — Tue, 29 Nov 2022 19:03:06 +0000

Onboarding the next wave of users to Web3 is a massive undertaking that many projects in the ecosystem are building for. One project with a unique approach to this is Celo, a layer-one blockchain network. Celo gives a superior new-user experience by being a mobile-first layer-1 blockchain that is easy to use with just a mobile phone. Your phone number acts as your address rather than a complex string, and the network allows users the option to pay gas fees with other tokens than the native currency.

However, the user experience is just one side of the onboarding coin. Developer experience is the other. After all, a new network is just as good as the RPCs that let you use it. Only some developers have the resources to run a node.

Infura, one of the most popular Web3 node providers, now offers Celo Network RPC nodes to all users. So if you want to start building on this mobile-first network, there’s never been a better time. Before you start building, let’s learn more about Celo.

This article will provide a high-level overview of the Celo Blockchain Network and how you can start building on it using Infura.

What is Celo?

Celo is a high-throughput layer-1 network that focuses on mobile users.

Mapping Phone Numbers to Public Keys

Celo is easier for mobile phone users than other networks. Celo maps phone numbers to public keys, allowing users to send tokens to people who don’t have wallets. A decentralized attestation protocol does the mapping and links an account to a phone number. This service never receives the phone number in clear text to maintain privacy.

As a result, user experience is better than most blockchains, as all interactions are done through phone numbers, rather than 30+ character-long strings that are easy to make mistakes with and impossible to memorize.

Paying Gas Fees with ERC-20 Tokens

Another usability hurdle is that most networks require users to pay gas fees with a native token. This results in users exchanging other tokens for native ones just to be able to send transactions.

This is a problem for two reasons. First, it adds a non-trivial step to every transaction if the user doesn’t have enough native tokens. Second, exchanging tokens is taxable in some countries, so they need to keep track of each time they exchange to a native token just to cover gas fees.

With Celo, you can pay with any approved ERC-20 token currently available, even stablecoins, lowering yet another barrier to entry and making costs more predictable. However, there is one caveat: transactions paid with non-CELO gas currencies will cost roughly 50k additional gas. It’s also important to note that there is a governable list of accepted currencies.

When developing, Celo comes with a dapp SDK called ContractKit. This SDK is a suite of packages that make building on Celo more straightforward. Connect, one of ContractKit’s main packages, acts as a wrapper around web3.js that handles the different currencies to pay the fees.

You can set your preferred currency as default for all transactions, like in this example:

import { CeloContract } from "@celo/contractkit"

const accounts = await kit.web3.eth.getAccounts()
kit.defaultAccount = accounts[0]
await kit.setFeeCurrency(CeloContract.StableToken)

With this in your code, you are setting the default currency if the feeCurrency field is left blank when sending a transaction. The user can still select another currency to use.

ContractKit comes with a list of contract addresses that include all core Celo currencies. In the example CeloContract.StableToken refers to cUSD.

It’s also possible to set your preferred currency per transaction. In this example, we send cUSD and also pay with cUSD.

const contract = await kit.contracts.getStableToken()
await contract.transfer(recipientAddress, amount)
  .send({ feeCurrency: contract.address })

Celo’s virtual machine is also EVM compatible since it originated as a fork of Geth. This compatibility enables you to reuse most of your Solidity skills when deploying your smart contracts on Celo. However, there are some notable differences.

The first difference is that transaction objects have additional fields like feeCurrency, gatewayFee, and gatewayFeeRecipient. They provide full-node incentives and allow users to pay their gas fees with different tokens. This doesn’t affect you when porting smart contracts from Ethereum to Celo, but it could be an issue when porting from Celo to Ethereum.

The second difference could have implications for your Ethereum-based smart contracts. The DIFFICULTY and GASLIMIT opcodes aren’t supported, and the fields are also missing from block headers.

A third difference is that the key derivation path is m/44'/52752'/0'/0 and not m/44'/60'/0'/0 like in Ethereum. Essentially, this derivation path allows wallets to generate different keys from one seed phrase.

The Network is Carbon Negative

CO2 production by blockchain networks has been a huge talking point in the last few years. Coming from Bitcoin, many of the early networks used the Proof-of-Work consensus algorithm to eliminate Sybil attacks.

The Celo protocol uses BFT Proof-of-Stake, which minimizes energy usage of the network by over 90%. Plus, it can create a new block in five seconds, less than half the time Ethereum needs.

Furthermore, all blocks are finalized immediately, so you and your users don’t have to wait for their actions to be written on-chain.

All this optimization still produces CO2, so Celo uses projects like Wren, a carbon offset subscription service that offsets 65.7 tons of CO2 monthly to get carbon negative. With tech-funded rainforest protection, Celo has already saved over 30,000 tons of CO2.

Why Use Celo with Infura?

Infura offers free RPCs for prominent wallets, and many big Web3 projects use them as their RPC provider, including Brave, Uniswap, Compound, Gnosis, and Maker, just to name a few. Additionally, Infura has achieved 99.99% uptime and about 10 times faster response times than other service providers like Alchemy or Quicknode.

ConsenSys, the company behind Infura also created and maintains crucial Web3 projects such as MetaMask and the Truffle Suite. So the shared know-how of creating wallets, dev tools, and RPCs creates synergies you won’t get from any other RPC provider. This also means you get trusted and complementary end-to-end tooling from the ConsenSys suite of products that flawlessly integrate with Infura RPCs.

With the release of Celo RPCs, Infura now supports 10 different networks, so you can build on multiple chains at once. Best of all, it’s free to access these networks and their archived data!

Summary

Celo is an exciting chain that tackles Web3 user and developer experience pain-points with innovative solutions. With its mobile-first approach, users can interact with the network and receive tokens with their phone number rather than a crypto wallet, making onboarding to the network easier for Web3 newcomers.

With the option to pay gas fees with other tokens rather than the native currency, Celo also removed a massive hurdle in the daily use of a blockchain network. Other networks require fees paid with a native and potentially volatile token.

Now that Infura offers RPC nodes for the Celo network, it’s the perfect time to start building on this mobile-first blockchain network. For more information, check out Infura’s docs.

How to Run Ganache in a Browser

Paul McAviney — Mon, 31 Oct 2022 17:49:43 +0000

When developing Web3 projects, it helps to have a local blockchain devnet for testing. Ganache is one of the most popular tools for this in the Ethereum ecosystem, and part of Truffle. Ganache allows you to set up a local blockchain with different settings to thoroughly test your smart contracts before deployment.

Seeing a local blockchain’s output in the terminal helps you to understand how your project will behave in a live environment. The ability to set the output to variables to manipulate some frontend code is even more useful. Some users may not know that you can do this by running Ganache in your browser.

This article explores how to run Ganache in your browser and highlights three great new features that make developing your Web3 projects easier.

Ganache in the Browser

Running a local blockchain instance to test your smart contracts is an essential step in the Web3 development process. By testing in this manner, you confirm things are working correctly before using a node service, such as Infura, to deploy your contracts to a testnet or mainnet. This minimizes the risk of ramping up daily limits and ensures you only need to deploy once. Ganache is an excellent tool that simulates the Ethereum network and allows developers to:

Fork any Ethereum network without waiting to sync
Establish block mining rules (instant, on-demand, intervals)
Impersonate any real account without needing their private keys
Make function calls with Ethereum JSON-RPC support

However, many who use this tool may be unaware that, since v7.0.0.0, Ganache can also run in your browser. Running in the browser allows you to set the local blockchain’s output to variables, which you can then use to test your frontend code. This visual process helps you to understand how your users will interact with your project and also enables you to test your dapp entirely offline (when using a local instance).

By first running Ganache in the browser and fine-tuning how your dapp reacts, you can easily switch the provider to your node service API once things are working as intended. Additionally, since Ganache’s latest update (v7.3.2 at the time of writing), you can now fork the Ethereum mainnet when running Ganache in the browser. This allows you to interact with real accounts and contracts through your frontend code.

The Project

In this section, we will create a basic smart contract using Truffle and its VS Code extension. Then, we’ll first deploy our contract to Ganache via the command line. Afterward, we will create a simple frontend to use Ganache in the browser and interact with our deployed contract.

Requirements

For this project, we will use the following:

Step 1 – Installation

First, we can run the command node --version in our terminal to ensure NodeJS and NPM are properly installed on our machine.

Next, we will install Truffle and Ganache by running the following command:

npm install -g truffle ganache

Checking the version number for Truffle and Ganache with truffle --version and ganache --version respectively will tell us if both tools were installed successfully.

The next step is to install VS Code, then navigate to the Extensions tab in the editor and search for Truffle for VS Code.

With everything now installed, we are ready to start working on the project.

Step 2 – Set Up the Project

With the Truffle for VS Code extension, we can easily create a new Truffle project through the VS Code command palette. Press ctrl + shift + P in the editor to open up the command palette and type truffle to see a list of commands we can use. Select Truffle: New Solidity Project and then create basic project to create a new project in the desired folder.

This creates an initialized project with a simple folder structure and example code we can use if we wish.

The ability to use console.log in our smart contract code is another great new feature recently available for Ganache. Before we create the smart contract for our project, let’s set that up by installing the required package. Navigate to the project folder in the terminal and type the following command:

npm install @ganache/console.log

Step 3 – Write the Smart Contract

The smart contract for our project will be a basic one we can donate some ETH to and request to see the balance.

In the contracts folder, create a new file and call it SimpleContract.sol. Next, fill it with the following smart contract code:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import '@ganache/console.log/console.sol';

contract SimpleContract {

  constructor() {
    console.log('\n\n#################################################\n'
    '####         Now Deploying Contract          ####\n'
    '#################################################'
    );
  }

  function donate() public payable {
    console.log('Successfully Donated ', msg.value);
  }

  function getBalance() public view returns (uint256) {
    console.log("This contract's balance is:", address(this).balance);
    return address(this).balance;
  }

  // Needed in order to receive payments
  receive() external payable {}

}

The code in our smart contract is relatively simple. It displays a message in the console when we deploy our smart contract, provides the functionality to donate ETH and query the balance, and prints messages in the console when calling the functions.

Step 4 – Deploy to Ganache

After installing the Truffle for VS Code Extension, we can easily deploy by right-clicking the smart contract file and choosing Deploy Contracts. However, if we want to see our console messages, we will have to use our own terminal rather than the one built into VS Code. This could potentially change in the future, but for now, we will have to create a simple migration script to carry out the deployment.

In the migrations folder, create a new script called 1_SimpleContract.js and input the following code:

const SimpleContract = artifacts.require("SimpleContract");

module.exports = function (deployer) {
  deployer.deploy(SimpleContract);
};

Next, open up a new terminal window and start Ganache:

ganache

This terminal window is where we will see our console messages when they appear. We now have two terminal windows open: one running Ganache and the other open in the folder of our Truffle project.

In the terminal window that’s open in our Truffle project’s location, type the following command to initiate the deployment:

truffle migrate --network development

If the deployment is successful, we can see our console message printed in the terminal:

Great! Our contract is live on our local Ganache instance! We’ll leave Ganache running for now so we can interact with our contract using the browser. Before we get to that, copy the contract address from the output in the terminal where we typed the migrate command. We will use this address to point our frontend to our smart contract.

Step 5 – Build the Frontend

5.a – Setup

For the frontend of this project, we will use React. Navigate to a new empty folder and type:

npx create-react-app ganache-browser-test

Next, we will install Web3.JS to easily interact with our smart contract. Navigate into our new project folder and install Web3.JS with this command:

cd ganache-browser-test
npm install web3

Newer versions of create-react-app don’t play nicely with Web3.JS, so we need to install a specific version of React Scripts. We can do so with this command:

npm install --save-exact react-scripts@4.0.3

Finally, to use Ganache in our browser, we will install it directly as a dependency:

npm install ganache

Alternatively, you can add the CDN link in the html to access Ganache from the browser:

<script src="https://cdn.jsdelivr.net/npm/ganache@7.3.2/dist/web/ganache.min.js"></script>

Before we start working on the frontend code, we need to create a file containing our contract’s ABI so that we can interact with our smart contract. We can copy that file directly from our Truffle project. Navigate to the build/contracts folder in our Truffle project and copy the SimpleContract.json file.

Next, open up our frontend project in the editor and create a new folder called abi. In that folder, paste the SimpleContract.json file. The file structure for our frontend now looks like this:

5.b – The Frontend Code

With all the setup out of the way, we can start working on our frontend. First, open the App.js file in the src folder and replace the boilerplate code with this:

import { useState } from 'react';
import './App.css';
import SimpleContract from './abi/SimpleContract.json';

const ganache = require('ganache');
const Web3 = require('web3');

const options = {}  
const provider = ganache.provider(options);

const web3 = new Web3('http://127.0.0.1:8545');  

const CONTRACT_ADDRESS = 'YOUR_CONTRACT_ADDRESS'  
const USER_ADDRESS = web3.utils.toChecksumAddress('YOUR_ACCOUNT_ADDRESS');

const contractInstance = new web3.eth.Contract(SimpleContract.abi, CONTRACT_ADDRESS);

const App = () => {
  const [contractBalance, setContractBalance] = useState(0);

  const donate = async () => {
    const donationAmount = document.querySelector('#donationAmount').value;

    const response = await contractInstance.methods.donate().send({
      from: USER_ADDRESS,
      value: web3.utils.toWei(donationAmount)
    });

    console.log('donate response:', response);

  };

  const getBalance = async () => {
    const response = await contractInstance.methods.getBalance().call();

    console.log('getBalance response:', response);

    setContractBalance(web3.utils.fromWei(response));

  }

  return (
    <div className="App">
      <header className="App-header">
        <h1>Ganache In The Browser</h1>

        <div>
          <input
            type='number'
            id='donationAmount'
            defaultValue={0.01}
          />
          <label htmlFor='donationAmount'>ETH</label>
          <br></br>
          <button
            id='donate'
            type='button'
            onClick={donate}
          >
            Donate
          </button>
        </div>

        <div>
          <button
            id='getBalance'
            type='button'
            onClick={getBalance}
          >
            Get Contract Balance
          </button>
        </div>

        <div>
          <p>
            {contractBalance} ETH
          </p>
        </div>


      </header>
    </div>
  );
}

export default App;

Be sure to change CONTRACT_ADDRESS to the address we received when deploying our smart contract back in Step 4. As well, the USER_ADDRESS is the account that will call the functions. We can get this from the list of accounts that displays when we first started our Ganache instance in the terminal:

Any of these account addresses will work.

Before we move on, let’s take a second to walk through the code we wrote:

We import our dependencies and SimpleContract JSON file.
Set the ganacheand Web3 variables.
Create an empty options variable that we initialize our provider instance with.
- Note: This options variable is where we would set any of the options we would like our local blockchain instance to include, such as forking Mainnet or Goerli, when running Ganache strictly in the browser (without it running in our other terminal window).
Initialize our web3 object using our localhost URL and port 8545, where our Ganache instance is already running.
- Note: You can run Ganache strictly in the browser at this point by using the provider variable instead of localhost. We are using localhost in this case since we want to interact with our already deployed smart contract and see our console.log messages in the terminal output.
Set our CONTRACT_ADDRESS and USER_ADDRESS variables.
Create a contract instance we can use to call our functions in the App code.
Create the contractBalance React state variable and its set method.
Define our donate and getBalance functions.
Finally, we return the html for our frontend.

5.c – Run the Project

Now we can run our app with npm start to display our frontend, which looks like this:

When we test our project, we can see the results and our console.log messages displayed on the terminal window which is running Ganache, and the ETH balance on our frontend successfully updates with the new balance.

Step 6 – Fork Goerli or Mainnet with Ganache in the Browser

Now that we know our project functions properly on a locally running instance of Ganache, the next step is to run it on a forked version of a testnet and then mainnet. We won’t run through the actual process of doing that in this article, but setting it up to do so is simple. All we need to do is change a few lines of our frontend code.

First, the options variable needs to specify which network we wish to fork:

const options = { fork: { network: 'goerli' } };

Or:

const options = { fork: { network: 'mainnet' } };

Then we need to update our web3 variable declaration:

const web3 = new Web3(options);

Finally, we need to make sure that we update CONTRACT_ADDRESS with our address on whichever network we are forking. We also need to update USER_ADDRESS to an account address on the same network that has sufficient funds to donate to our contract.

When forking mainnet, that section of code could look something like this:

const options = { fork: { network: 'mainnet' } };
const provider = ganache.provider(options);

const web3 = new Web3(provider);

const CONTRACT_ADDRESS = '0x692586eaC70114C8F4714D89E7f72FAAbaeE0Cd7'  
const USER_ADDRESS = web3.utils.toChecksumAddress('0xCe7A99Bba7018fa455E6eD5CF88a7F26010F1E8F');

And with that, we could test our project with a forked version of mainnet using Ganache in our browser.

Conclusion

Testing projects by creating an interface helps to visualize how your dapp is running and gives you a better idea of how it will perform for users once on mainnet. Running in your browser while testing your frontend code is one of the features that make Ganache such a powerful tool in your development toolkit. For more information about working with Ganache or to contribute to the project, check out their Github or documentation.

Infura’s Plans To Launch A New Decentralized Infrastructure Protocol And Why It Matters

Paul McAviney — Wed, 21 Sep 2022 14:37:21 +0000

Introduction

At ETH Berlin recently, Infura announced plans for a new decentralized infrastructure network. This decentralized network has the potential to vastly improve how web3 developers and end-users access and interact with the data on blockchains.

Why is this a big deal? And what could it mean for Web3? Let’s take a look.

Decentralized Protocols

One of the most important innovations Web3 and blockchain technology make possible are decentralized protocols—networks and communities where anyone and everyone can participate. Protocols are a powerful new form of human coordination using technology and protocols like Bitcoin and Ethereum have led the way for so many others to emerge: NEAR, Polygon, and Arbitrum, just to name a few.

But what about the infrastructure and protocols that exist on top of these networks? Many companies creating the building blocks are operating in Web2 terms with centralized ownership and access to their services. As Web3 technology grows and matures, the need for decentralized protocols and infrastructure grows with it. That’s why Infura is launching a new infrastructure protocol for node services.

Node services are how some dapps access blockchain data in Web3. While some larger organizations choose to host their own nodes, self-hosting can be complicated and expensive. As a result, many developers rely on companies like Infura to manage the infrastructure and blockchain access for them.

A decentralized infrastructure protocol—one that offers this access but isn’t controlled by a single centralized entity—is a critical piece to completing the Web3 tech stack.

What is a Decentralized Infrastructure Protocol?

Let’s break down this question of centralized versus decentralized a bit further.

In a centralized node service, a single entity controls the protocol and infrastructure. Similar to how Web2 companies like Twitter or Facebook: one entity hosts the server that ensures the service is operational, gatekeeping the user data and pocketing the revenue. As a result, end-users like you and me only have one entry point into the service, and zero control over what happens behind the scenes.

In the case of a node provider, a single entity is responsible for keeping the service operational, the infrastructure running, and the node responses flowing. While there are multiple nodes running, they are all controlled by this single entity. If the centralized entity or its infrastructure goes down, so does the entire service, along with any applications that rely on that service. Remember when Facebook went offline on October 4th in 2021? That’s a prime example. Millions of people and services were disconnected as a result of their server outage. This is the principal shortcoming of centralized infrastructure: it can never guarantee 100% uptime the way a decentralized network can.

In a decentralized node service, there are multiple entities all joining together to support the protocol, host the nodes, validate the data, and distribute the risk of infrastructure. The decentralization of responsibilities is closer to the ultimate goals of Web3 and a truly permissionless infrastructure.

And, because there are multiple providers, users will have the choice of which provider to use. If a provider goes down, or one makes technical decisions the user doesn’t like, then the user can easily switch to a new provider.

With this many actors, there’s a requirement for ways to agree on upgrades, revenue sharing, architectural changes, and so on. We can already see this on Ethereum with the EIP system. From past experience, this often means implementing decentralized governance like a DAO.

Why is Decentralized Infrastructure Important?

So why is this decentralized node protocol a big deal?

As I mentioned earlier, decentralized networks have progressed significantly as well as some of the protocols, DeFi above all. However, decentralized data access is one of the most important components of the Web3 tech stack.

Until now, node access has been mostly centralized, since the vast majority of users access the blockchain through the node providing services. Without a decentralized node access protocol and infrastructure, we don’t really have decentralized Web3, which is the ultimate goal of this industry and ecosystem. A decentralized infrastructure protocol gives us:

High-throughput and reliability - a proven architectural solution spread out over multiple entities reduces the risk of downtime and failures. It can ensure that users can access the data they need.
Increased transparency - decentralized solutions, like open source software, often result in a higher level of transparency.
Improved cooperation - Instead of competing, protocol providers collaborate to create a more effective and reliable infrastructure protocol.

How this will evolve is yet to be seen, but Infura plans to release the new protocol in stages.

What Can You Do?

Since Infura’s announcement at ETH Berlin was high-level, we don’t know yet how this decentralized infrastructure protocol will be implemented.

That said, there was an open call for infrastructure providers to get involved. Qualified providers can sign up for the early access program to help construct the test network. In the announcement, they listed the following qualifications:

Experience running blockchain infrastructure
Willingness to actively participate and provide feedback
Interest in decentralizing blockchain API access

If you want to learn more about this decentralized network, keep an eye on Infura’s official channels for more information.

How Does Polygon Help Ethereum Scale?

Paul McAviney — Mon, 12 Sep 2022 20:20:04 +0000

Introduction

Since its inception in 2014, Ethereum has established itself as the de facto leader of blockchain platforms capable of supporting turing-complete smart contracts.

Ethereum has been instrumental in bringing about a revolution that we now know as web3. The largest decentralized exchange, NFT marketplace, and yield farming protocol all reside on Ethereum. The chain is responsible for handling billions of dollars worth of value, and it has opened up avenues for creators and investors that were previously unfathomable.

Although Ethereum dapps have enjoyed an immense amount of popularity amongst their users, they are nowhere close to achieving mass adoption. The sum of people who have used dapps still number only in the few millions. One of the biggest reasons for this is the scaling handicaps endemic to the chain. It becomes unusable very quickly for everyone barring a few high net-worth users.

Fortunately, there have been serious efforts made by the community to help Ethereum scale. By far, the most popular scaling solution available in the market today is the Polygon POS (Proof of Stake) sidechain. In this article, we are going to explore what Polygon is and how it overcomes Ethereum’s drawbacks. Finally, we will make a side-by-side comparison of both chains’ performances by creating an NFT-minting smart contract.

The Problem with Ethereum

Ethereum, despite its market leader position, suffers from a host of problems:

Low Transaction Throughput: Ethereum can handle only 15 transactions per second. Compared to solutions like Visa or Mastercard, which handle over 25,000 transactions per second, this figure is scant.
High Gas Fees: When a chain can handle few transactions, it must increase processing costs when the transaction volumes are high. Ethereum is notorious for its high gas fees. For instance, not long ago, it reached almost 7000 Gwei during a popular NFT mint (called Otherside). During this period, it would’ve cost you in excess of $500 to perform even the most basic transaction.
Slow Transaction Finality: Ethereum adds a block to its chain approximately once every 15 seconds. Since there are multiple miners competing to mine blocks at the same time, a block cannot be considered final until at least 4-5 blocks have been added on top of it. In essence, it takes more than a minute for a transaction to be considered final. With applications like games and financial tools, such a slow transaction finality is simply not acceptable.

The Solution

In order to achieve mass adoption and acceptance, it is imperative that a solution be developed on top of Ethereum that addresses its most glaring problems. In essence, we need a solution that has the following features:

Low-cost: Even the most computationally intensive transactions shouldn’t cost more than a few cents.
Fast: Transactions are confirmed almost instantly.
EVM Compatible: Developers don’t need to learn new tooling or languages in order to build on the solution.
Interoperable with Ethereum: Easy to deposit and withdraw funds to and from Ethereum and the solution.
Engaged community: A community that is committed to improving the solution over time as well as building user-friendly dapps on top of it.
Sustainable: Any solution looking to reach mass adoption must also be environmentally conscious.

Ethereum core developers are working on Layer 1 scaling fixes, such as sharding, but these solutions are nowhere near completion. We need solutions available today that are easy for anyone to get started on.

Introducing Polygon

The creators of Polygon designed a chain with all the aforementioned features in mind. Since its inception in 2017, the Polygon chain has gone on to become one of the most popular Ethereum scaling solutions.

Technically speaking, Polygon is an Ethereum sidechain. A sidechain is an independent blockchain that is connected to Ethereum via a bridge. Unlike L2s, sidechains do not inherit the security features of the main Ethereum chain. Instead, they implement their own consensus protocols and block parameters. As a result, sidechains aren’t required to post state changes and transaction data to Ethereum (whereas L2s are).

The greater independence of sidechains from Ethereum makes Polygon slightly more centralized but also enables it to achieve extraordinarily high levels of throughput.

The following are the improvements that Polygon has been able to achieve over Ethereum:

High transaction speeds: Polygon is capable of handling up to 65,000 tx/second, comparable to the scale of its centralized rivals.
Low transaction costs: Even the heaviest transactions on Polygon cost only a few cents. In most cases, a 10,000x reduction in cost can be observed vis-à-vis Ethereum.
Instant transaction finality: Polygon’s consensus protocol guarantees that transactions are confirmed almost instantly (less than 2 seconds).
EVM compatible: Polygon is built on the same software as Ethereum. Therefore, Ethereum developers can build on Polygon using the exact same tools.
Strong community: The Polygon team has spent millions of dollars to build a robust community of builders, investors, and users. It is already home to some of the most popular dapps on Ethereum with better UX and much cheaper costs.
Low energy consumption: Polygon uses the Proof-of-Stake protocol, which consumes 99.9% less energy than its PoW counterpart. In fact, Polygon has committed to being carbon negative by the end of 2022, making it one of the largest environment-friendly blockchains in the market today.

A Note on Polygon PoS Security

Unlike other sidechains, Polygon PoS does have a method in which it is able to inherit the security of Ethereum. The Polygon PoS chain utilizes the Plasma Bridge in order to maintain and guarantee a high level of security. Plasma has a unique exit mechanism, basically a set of smart contracts to help move assets and checkpoints for verification, which enables Polygon PoS to leverage Ethereum’s security.

The only drawback here is withdrawals from Polygon to Ethereum through the Plasma Bridge must go through a 7-day withdrawal period. Quicker withdrawals (within 30 minutes to 3 hours) are possible with the PoS Bridge, however, this method is not as secure as using the Plasma Bridge.

Both these bridges are still secure and safe to use, and in most cases should suit a user’s needs just fine. However, if your project requires state-of-the-art security, it is prudent to consider using Polygon L2 solutions such as Zero, Nightfall, and Hermez.

Comparison in Action

Now that we've seen the advantages that Polygon PoS has over Ethereum for certain projects, let's analyze deployment to both chains.

In the following sections of this article, we will create a simple NFT contract and deploy it to Polygon Mumbai and Ethereum Goerli testnets. We will observe how the development process for both chains is nearly identical.

Next, we will analyze NFT contracts that have been deployed previously (by other teams) on Ethereum and Polygon mainnets, and then compare cost and confirmation times.

Overview of the NFT Project

The project that we're going to create is extremely simple. We want to write and deploy an ERC-721 contract that mints a single NFT to the blockchain of our choice.

The first step in such projects is to create the NFT art, its associated metadata, and upload it to IPFS. For this tutorial, we have already done this for you.

You can check out the image uploaded to IPFS here and the associated NFT metadata here.

In case you're interested in learning more about NFT metadata, IPFS, and Pinata, check out this article here.

Creating the NFT Contract

Step 1: Install the MetaMask Extension

In case you haven't already, install the MetaMask extension for your browser. Once installed, MetaMask will guide you through creating your first wallet.

Step 2: Add Goerli and Mumbai Chains to MetaMask

By default, MetaMask comes with the Ethereum mainnet and the Goerli testnet configured. To add the Polygon mainnet and the Mumbai testnet chains, follow the instructions in this document.

Step 3: Get GoerliETH and Mumbai MATIC from a Faucet

Head over to Alchemy's Goerli faucet page and request some free GoerliETH. You may be required to create a free Alchemy account for this.

If all goes well, you should have 0.05 GoerliETH in your wallet when you switch to the Goerli test network.

In the same vein, acquire some free Mumbai MATIC from Polygon's official faucet. If successful, switching to the Mumbai chain should tell you that you have a balance of 0.2 MATIC.

Step 4: Install NPM and Node

We will build our project using JavaScript and node. In case you don't have node and npm installed on your local machine, you can do so here.

You can ensure that everything is working properly by checking the version number of node on your terminal.

$ node -v

Step 5: Create a Node Project and Install Dependencies

Let's set up an empty project repository by running the following commands:

$ mkdir nft-contract && cd nft-contract
$ npm init -y

We will be using Hardhat, an industry-standard Ethereum development environment, to build and deploy our smart contract. Install Hardhat by running:

$ npm install --save-dev hardhat

We can now create a sample Hardhat project by running the following command and choosing Create a basic sample project.

$ npx hardhat

Agree to all the defaults (project root, adding a .gitignore, and installing all sample project dependencies).

To check if everything works properly, run:

$ npx hardhat test

We now have our Hardhat development environment successfully configured. Let us next install the OpenZeppelin contracts package. This will give us access to ERC-721 implementations (the standard for NFTs), on top of which we will build our contract.

$ npm install @openzeppelin/contracts

Step 6: Writing the Smart Contract

Open the repository in your favorite code editor (e.g. VS Code). In the contracts folder, create a new file called NFTContract.sol.

We are going to create a very simple ERC-721 contract that mints a single NFT when deployed (i.e. within the constructor). Add the following code to the file:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

contract NFTContract is ERC721URIStorage {

    constructor() ERC721("Panda NFT", "PNFT") {

        // Mint NFT
        _mint(msg.sender, 0);

        // Set metadata
        _setTokenURI(0, "ipfs://QmUyZoK21qb8YknXGfDB34RTY8vMqPb6Bsj9U9iLEnyrZR");

    }
}

Step 7: Deploy the Contract Locally

Let's now write a script to deploy and test the contract locally. In the scripts folder, create a new file called run.js and add the following code:

const hre = require("hardhat");

async function main() {

  const contractFactory = await hre.ethers.getContractFactory("NFTContract");
  const contract = await contractFactory.deploy();

  await contract.deployed();

  console.log("Contract deployed to:", contract.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
});

Now run the following command on your terminal:

$ npx hardhat run scripts/run.js

Step 8: Deploy the Contract to Goerli

In order to deploy the contract to Goerli, we have to add the network to the hardhat.config.js file. Replace the module.exports object at the end of the file with the following:

module.exports = {
  solidity: "0.8.4",
  networks: {
    goerli: {
      url: "https://ethereum-goerli-rpc.allthatnode.com/",
      accounts: ["<-- WALLET PRIVATE KEY -->"]
    }
  }
};

Replace the placeholder with your MetaMask wallet's private key. (This can be found in Account Details.) Take care to never share this key or file publicly.

To deploy to the Goerli testnet, run the following command:

npx hardhat run scripts/run.js --network goerli

If all goes well, your terminal will display the address of the deployed contract on the Goerli network. Head over to https://goerli.etherscan.io and search for your contract address to view your contract.

You can find the contract that we deployed here.

Step 9: Deploy the Contract to Mumbai

Let's now deploy our contract to the Polygon Mumbai network. The best part of this step is that we have to change absolutely nothing in our contract or the run script. The only thing we need to add is the mumbai network to hardhat.config.js.

module.exports = {
  solidity: "0.8.4",
  networks: {
    goerli: {
      url: "https://ethereum-goerli-rpc.allthatnode.com/",
      accounts: ["<-- WALLET PRIVATE KEY -->"]
    },
    mumbai: {
      url: "https://rpc-mumbai.maticvigil.com",
      accounts: ["<-- WALLET PRIVATE KEY -->"]
    }
  }
};

Deploy to Mumbai by running:

npx hardhat run scripts/run.js --network mumbai

You can search for your contract address at https://mumbai.polygonscan.com. You can find our contract here.

You can also search for your Goerli and Mumbai NFTs on OpenSea Testnets. For example, here is the NFT we minted on the Mumbai network.

Comparing Cost and Time

By now, it should be abundantly clear that developing for Ethereum and the Polygon sidechain is nearly identical.

But what are the cost and time implications?

We won't be able to answer these questions with the contracts we deployed since we were operating on testnets using fake money.

But not to worry. We have deployed these contracts to the Ethereum and Polygon mainnets on your behalf. Let’s take a look at the performance.

Ethereum

You can check out the deployed NFT contract on Ethereum here and the contract creation transaction here.

Despite the recent drops in Ethereum prices (in terms of USD) and average gas prices (in terms of gwei), you can see that contract deployment cost around 0.02 ETH or $40.

The time to confirm this Ethereum transaction was approximately 40 seconds.

Polygon

You can check out the deployed NFT contract on Polygon here and the contract creation transaction here.

Notice that we paid 0.06 MATIC when MATIC was trading at $0.94. Therefore, we paid $0.06 to deploy the contract.

The time to confirm this transaction was 6 seconds.

In essence, this contract was confirmed almost 7 times faster and with a cost reduction of 1000x!

Conclusion

Ethereum is easily the most important smart contract blockchain in existence. However, it faces huge obstacles when it comes to scale and transaction costs.

Hopefully, this article has made a strong case for why Polygon is an excellent panacea to Ethereum's scalability problems. By operating as a PoS sidechain, it significantly increases processing speeds and reduces costs.

For Ethereum developers, building on Polygon requires almost zero additional upskilling. Ethereum tools are compatible with both environments. To start building on Polygon, check out the documentation here.

No-Code: Buy Me a Coffee With Coinbase!

Paul McAviney — Tue, 19 Jul 2022 15:40:43 +0000

Summary: How I easily installed a Buy Me A Coffee type feature on my website to accept crypto donations, using minimal code.

Introduction

I never thought of myself as a writer. However, it turns out I actually have a knack for it! Learning new technology and then writing about it helps me solidify the concepts. As an added bonus, I’m able to help teach others on the same path as me. Creating technical content is fun! Eating cheap, frozen dinners every night is not. So how can I start accepting payment for all the hard work I’m putting in?

Some of my readers suggested I build a “Buy Me A Coffee” type feature on my website. This simple method to start accepting crypto donations could be my answer to move from frozen dinners to fresh produce!

This article will explain how I installed a method to receive crypto donations using no-code solutions by Coinbase Commerce. Then, we’ll build a simple project so you can see just how easy it is and how little code is involved.

The Problem: Broke But Still Building

I tell my readers and Twitter followers all the time that creating content around web3 tech is one of the best ways to learn it. Writing about something quickly points out any gaps in your knowledge. It’s a fast track to understanding these complicated networks and how they operate at a technical level. However, what I don’t tell them is that when you’re first starting out, writing technical articles doesn’t exactly pay the bills if you don’t have any clients yet.

Clients or not, helping others learn through content creation is rewarding. One of my favorite aspects of being a technical writer is when a reader reaches out saying that I helped them solve a problem or learn something new. Some of these readers even expressed interest in returning the favor. They suggested I build a “Buy Me A Coffee” type feature on my website. This seemed like an excellent way to get paid for the hard work I put into my content.

Building a feature like this from scratch sounds like a nightmare, though. I don’t have time to improve my frontend skills to do this properly; I just want to focus on web3 stuff! So I started looking for an easier solution—and found one with Coinbase Commerce.

The Solution: No-Code With Coinbase Commerce

Coinbase Commerce has easy-to-install payment gateways that make it simple to accept crypto. I can use this to create a “Buy Me A Coffee” feature on my site, no problem!

As a plus, I’m already familiar with Coinbase. I’ve been trading cryptocurrencies since 2017, and Coinbase was the first crypto exchange I ever signed up for.

Installing the donation gateway was easy. All I had to do was create the gateway in my Coinbase Commerce dashboard and then copy the code it generated onto my site. Then with only minor adjustments to the code, I got it to look how I wanted. Now I’m ready to start accepting crypto donations so I can hopefully treat myself to something a little better than frozen pizzas.

How to Install a Crypto Donations Button

For the rest of the article, we’ll run through creating a crypto donations button to show you just how easy it is. We’ll go through it step by step, so even if you’re not a developer, you’ll be able to start accepting crypto in minutes

What You’ll Learn

How to easily install a link on your website to start accepting crypto donations

What You’ll Need

A Coinbase Commerce account
The Google Authenticator App on your phone (for 2-step account verification)
A website to install your link on

Additional Resources

Coinbase Commerce Docs

Step 1 - Set Up a Coinbase Commerce Account

The first step in getting a button to accept crypto donations is to set up a Coinbase Commerce account. Head to https://commerce.coinbase.com/ and select the Get Started button. Follow the steps to get everything set up correctly.

Choose the Self managed option to get started with just an email address.
Verify your account through email.
Set up 2-step verification using the Google Authenticator app on your phone.
Set up a Coinbase Crypto Wallet.
- IMPORTANT!– Write down your seed phrase somewhere safe! Anyone with this seed phrase can empty your wallet!
- Verify your seed phrase in the next step.
- Lastly, you can save an encrypted version of your wallet to Google Drive if you want, but it’s not necessary.

After completing all the above steps, go to your new dashboard!

Step 2 - Whitelist Your Website

Now that you have a place to send any funds you may receive, the next step is to add your website to the whitelist. This just means adding your website to a list of approved websites that are allowed to host your new payment button. You wouldn’t want just anyone installing it wherever they want!

Click on your email address in the top right corner of the screen and select Settings.

Next, select the Security tab and click on the Whitelist a domain button. Enter the full URL of your website, including the https:// part. If this is successful, you will now see it in the list of approved sites.

Note: If you are a developer testing on a locally hosted instance of your website, you do not need to whitelist localhost.

Step 3 - Create a Checkout

The next step is to create the payment gateway your donate button will send the user to. Click on the Checkouts tab on the left-hand side of the screen, then select Create a checkout.

Fill in the details for your checkout, giving it a name, description, and image if you’d like. Then, select Let your visitors choose under the "What kind of pricing do you want to offer?” heading to accept donations. You can also ask for additional information from the person donating, but this is optional.

Once you have filled in the details, click on the Create checkout button at the bottom to finish. A popup will display some options for you to share your new checkout.

You can share your checkout link directly, copy the code to create the Donation Button on your website, or select View checkout to see it in action.

Step 4 - Add the Code to Your Website

The final step is to place the checkout code on your website. So navigate to your index.html or whichever page you want to put the button on and paste the code where it makes sense for you. For example, I added mine to the bottom of my hero section and changed the Button text to say “Buy Me A Coffee”.

Now clicking on the Donate button will send any charitable users to your shiny, new checkout page where they can donate as much as they like in multiple cryptocurrencies. Here’s what mine looks like:

Conclusion

Creating web3 technical content is challenging, yet rewarding. Any newcomer will see that it is a fast way to learn concepts quickly. However, they will also learn that being a content creator takes a while to start being a profitable career choice. This is where a “Buy Me A Coffee” button helps a lot.

This no-code solution makes things simple for anyone to make a crypto payment gateway in minutes. Now that I’ve got this fancy, new feature on my website, I can start accepting donations for all the hard work I put into creating content! No more frozen dinners for this guy! I’m moving up in the world!

If this article has helped you, maybe Buy Me A Coffee? ;)

Using Infura’s NFT API With Lootbox

Paul McAviney — Thu, 07 Jul 2022 20:59:10 +0000

Introduction

I’ve only been in Web3 for about a year now, but I can honestly say that NFTs are the most exciting aspect about it for me. I’m not talking about Apes or Punks, however. PFP (profile picture) projects and art, although cool and a simple proof of concept for the technology, won’t create a better world.

Instead, I’m excited about the actual utility of NFTs. Allowing gamers to own their assets, delivering fair royalty commissions to musicians and artists, and making concert tickets impossible to scalp while providing a sweet digital memento are some of the use cases I find interesting.

However, building and interacting with NFTs aren’t always the easiest thing to do. As developers, we need clear resources to build projects effectively in order to give our users a better experience.

I recently heard about Infura’s private beta for their NFT API, so I thought I would check it out and see how it could improve my development workflow. In this article, I will explore the capabilities of Infura’s NFT API and test it out using a Lootbox NFT sample project from Infura’s Github.

What is the Infura NFT API?

According to this blog post on Infura’s website, the NFT API will help me “accelerate my time to value” and allow me to interact with anything related to NFTs through a convenient SDK. In addition, I can build and verify my NFTs, create metadata templates and easily mint NFTs. So my first impression is that I can start creating and interacting with NFTs using API endpoints rather than building smart contracts and deploying them.

Sounds pretty useful! And I’m all for testing any tool that will help improve my development processes. Infura’s NFT API suite seems helpful for any dev transitioning from Web2, since you can run API endpoints without Solidity.

Now let’s dive deeper and see what this NFT API is capable of.

Infura NFT API Capabilities

A quick glance through the NFT API documentation on Infura’s website proves my first impression correct. I will be able to deploy and call methods on my NFT contracts using Infura’s API endpoints, without having to actually write the smart contract code. This is a huge time saver!

Deploying a contract is straightforward. I create the NFT metadata in JSON format, upload the metadata to IPFS in another Infura project, then create a simple deployment script and run it with node. I also have to make a .env file to hold some environment variables. My deployment script ends up looking something like this:

import { config as loadEnv } from 'dotenv';
import { SDK, Auth, TEMPLATES } from '@infura/sdk';

loadEnv();

const auth = new Auth({
      projectId: process.env.INFURA_PROJECT_ID,
      secretId: process.env.INFURA_PROJECT_SECRET,
      privateKey: process.env.WALLET_PRIVATE_KEY,
      chainId: 4,
    });

const sdk = new SDK(auth);

const myNFTContract = await sdk.deploy({
   template: TEMPLATES.ERC721Mintable,
   params: {
     name: 'My NFT Contract',
     symbol: 'MYNFT',
     contractURI: 'https://MY_NFT_METADATA_URL',
   },
 });
console.log(`Contract address is: ${myNFTContract.contractAddress}`);

Then, I run it with Node. Infura creates a smart contract for me and uploads it to Ethereum behind the scenes. After that, I just need to make sure I have some tokens for whichever chainId I have specified in my code. In this case, the Rinkeby testnet (chainId: 4). From here, I could mint NFTs from this contract or gather the contract metadata.

This is a much easier method to create an NFT contract than writing Solidity code and deploying it myself!

The NFT API also provides methods for gathering NFT info from wallets, transferring NFTs from one wallet to another, and a host of other NFT methods. These include adding an address to the minter list, setting royalty info, and changing the contract URI.

Overall, it seems that Infura’s NFT API indeed helps improve my development workflow. Having all the necessary functionality for building and interacting with NFTs packaged together in an easy-to-use SDK is quite convenient!

But enough about what it can do, let’s see how this API works!

The Lootbox Project

Along with the NFT API, Infura released an NFT Gallery Project on their Github to demo its capabilities. All I will have to do is input an Infura project ID and secret, then connect my MetaMask wallet to the dapp frontend. Then the dapp uses the API to fetch all my NFTs to display nicely in the frontend. So to break that down, I will need the following things for this project:

An Infura account
Infura Project ID and Secret
A MetaMask wallet extension with NFTs in it

Let’s get started!

Step 1 - The Infura Project ID and Secret

Before starting the Lootbox project, I want to gather the necessary items. So first, I’ll head to infura.io, log in, and create a new project. Then, I can grab the Project ID and Project Secret for use later.

Step 2 - MetaMask

This step will be quick because I already have the extension installed in my browser. If someone following along with this article doesn’t, however, head to metamask.io and download the extension for your specific browser. Then follow the steps to create a new account.

Next, I’ll sign in and switch accounts to the wallet address that holds my NFTs. If you need to acquire an NFT, you can head to your favorite marketplace and buy one or try to create one yourself using the Infura NFT API 😉. Either way, you will need some ETH in your wallet.

Step 3 - Setting Up The Project

With all the prep work out of the way, I can start building the project. So next, I’ll clone the project repo onto my local machine. I’ll first navigate to the folder I want to work out of and then type the following command:

git clone https://github.com/INFURA/nft-api-lootbox-gallery-app.git

Next, I will change directories into the project folder and install dependencies using yarn:

cd nft-api-lootbox-gallery-app
yarn

After everything is installed, the last thing I need to do is create a .env file to store my environment variables and secrets. I’ll just copy the file that’s already there and add my variables to it.

cp .env .env.local

Now I’ll open up the project and add my Project ID and Project Secret from my recently created Infura project. There’s also an option to input the Account Address of any wallet to view their NFTs, but I’ve got my own I want to see in the Lootbox NFT Gallery.

With all the setup out of the way, I can finally run the Lootbox project. But first, I want to browse through the code to see what’s happening under the hood.

Step 4 - The Lootbox Code

Based on the README file of the Lootbox project, the most important components are in the pages/index.tsx, hooks/useWallet.ts, and pages/api/assets.ts files. So I’m going to browse those and see if I can figure out how this project uses the Infura NFT API.

After looking through these files, I can see the pages/index.tsx file contains the code which displays the frontend for the project. If the showGallery state variable is true, then it should display my NFTs. If it’s false, then it should display the welcome text with the Connect Wallet button. This Connect Wallet button connects to some functions in the hooks/useWallet.ts file, so I’ll check there next.

In the hooks/useWallet.ts file, I can see the function which is supposed to grab my NFTs. Specifically, the getTokens function.

 const getTokens = async (accountAddress: string) => {
    try {
      const { data } = await axios.post('/api/assets', { accountAddress });
      return data.assets;
    } catch (error) {
      setTimeout(() => {
        setErrorMessage('Error getting tokens');
      }, 2000);
      return;
    }
  };

This function seems to make a POST request using a parameter from the /api/assets file and return the results with my assets. So looking into the pages/api/assets.ts file, I can see where the NFT API is being used.

  try {
    const { data } = await axios.get(  `https://nft.api.infura.io/networks/1/accounts/${accountAddress}/assets/nfts`,
      {
        headers: {},
        auth: {
          username: `${process.env.INFURA_PROJECT_ID}`,
          password: `${process.env.INFURA_PROJECT_SECRET}`
        }
      }
    );

    return res.status(200).json({
      assets: data.assets,
    });

This code calls the get function of the NFT API, using my Infura Project ID and Project Secret to access my account, and returns my NFTs in a JSON object. Following the path back to the pages/index.tsx file, if the getTokens function from hooks/useWallet.ts doesn’t timeout, it will return my NFTs, switch the setGallery state variable to true, and display my NFTs on the page.

Cool! So I’ve got an idea of how it works, let’s see it in action!

Step 5 - Running The Lootbox Project

To run the project locally, I just need to type:

yarn dev

After navigating to http://localhost:3000/, I can see a nice-looking frontend for the Lootbox Project.

Clicking on Connect Wallet prompts my MetaMask wallet to pop up to approve the connection request.

After connecting, it immediately starts fetching my tokens. This is the point where I now know the dapp is using the NFT API.

Once the fetch is successful, it displays my NFTs in a fancy gallery, allowing me to browse and choose each one to get a better look at them. Neat!

Conclusion

My verdict on the Infura NFT API is that it's a tool that cuts down my development time, and there’s quite a bit I can do with it. It’s handy to build, mint, and interact with NFTs from an easy-to-use API. Although I am more familiar with building NFT contracts with Solidity and deploying them with Truffle, I can easily see how this would help smooth the transition of a Web2 dev into Web3. Using JavaScript rather than writing a smart contract will be a huge time saver for many Web2 developers.

I would suggest trying the NFT API out for yourself. It’s still in private beta, but anyone can register. For more information on its capabilities, you can check out this YouTube demo or Infura’s documentation.

Accessing Ethereum Archive Nodes with Infura

Paul McAviney — Wed, 01 Jun 2022 15:18:52 +0000

Introduction

Archive nodes are particular nodes on the Ethereum Network that store historical blockchain data. Because they offer this historical information, they are helpful when you need to audit past transaction history or gather data. Services like Etherscan and Dune Analytics use archive nodes, but anyone can run one themselves.

In this article, we will review the different types of Ethereum nodes, dive deeper into Archive Nodes, and introduce the new archive node capabilities of Infura. We’ll then walk through a real-world project to show how to connect the Infura API and web3.js to a pre-built react frontend. Once complete, the user will be able to query an Archive Node for some statistics for a given Ethereum wallet address.

What are Ethereum Nodes?
Types of Ethereum Nodes
Archive Nodes
Archive Node Providers
The Project
Conclusion

What Are Ethereum Nodes?

In simple terms, a node is just a connection point in a network. However, in the case of Ethereum, different types of nodes hold various responsibilities to the network.

The Ethereum blockchain operates on what is called the Ethereum Virtual Machine (EVM), which is a type of decentralized global computer. Nodes, in this case, provide the processing power for this computer. They serve requested data, create and validate blocks, store transaction data or smart contract code, and much more. Anyone with the required hardware can download an Ethereum client and spin up their own node to participate in the network. This also prevents any single entity from controlling the entire network and contributes to Ethereum’s decentralization.

There are four main types of Ethereum nodes, each contributing to the network differently. Together they relay information to other nodes, verify transactions and the EVM state, and provide the infrastructure needed to keep the Ethereum Network operating efficiently. They communicate with one another to ensure they all agree on the state of the network. Therefore, having more nodes makes the network stronger and more resilient to attacks.

Types of Ethereum Nodes

Full Node

Full Nodes verify transactions and EVM state, validate blocks, launch and execute smart contract code, and can serve network data when requested. They also store the state of the Ethereum Blockchain up to the most recent 128 blocks but can build an archive of historical states on demand.

Mining Node (Commonly referred to as a “Miner”)

A Miner is a Full Node running a mining client. In its present state, Ethereum provides consensus through the proof-of-work algorithm. To summarize, this means a mining node competes in a computation race with other mining nodes to create the next block. Once created, the new block is broadcast to the network to be verified by other nodes and appended to the end of the blockchain.

Light Node

A Light Node is a “light” version of a Full Node, which only contains block header data such as the previous block’s hash and a timestamp rather than the block data in its entirety. They make on-demand requests to Full Nodes and only validate certain pieces of state as required by their users. Example uses are to check balances, verify if a transaction was confirmed, check event logs, and do other light-duty tasks. Light Nodes can be easily run by lower-capacity devices such as a mobile phone or RaspberryPi.

Archive Node

An Archive Node is a type of Full Node that is running in “archive mode”. They contain all the same data as a Full Node but also all the historical state data of the entire blockchain since Genesis Block. We’ll focus on archive nodes for the remainder of this article.

More on Archive Nodes

Although Full Nodes can rebuild historical blockchain state data, this process is slow and inefficient. Depending on the use case, this data may need to be served up quickly. This is where Archive Nodes come in. Because Archive Nodes contain historical data from the very first block, they can easily trace any arbitrary transaction at any time.

Why Access an Archive Node?

If there is information you need to get from the Ethereum Blockchain before the most recent 128 blocks, the most efficient way to get this is through an Archive Node. Some of this information may include account balances, smart contract code, transaction counts, or the value at a particular storage position. They also enable the testing of smart contract code without creating a transaction on the blockchain.

Specs to Run an Archive Node

Running your own node means having more control of the information you share with the blockchain. You can create more secure and private dApps (decentralized apps), and your addresses and balances won’t leak to random nodes on the network. Running an Archive Node also means quick access to historical blockchain data without signing up for any third-party services.

These are the specifications you would need to be able to run your own Ethereum Archive Node:

A CPU with at least four cores
16 GB or more of RAM
An SSD drive with at least 6 TB of space
At least 25 MBit/s bandwidth

As you can see, the requirements to spin up an Archive Node make it reasonably accessible. Not exactly cheap, but still within reach to an individual. It does require some technical know-how and constant upkeep though. If you don’t have the time, drive, or equipment to run your own, a Node Provider is a great alternative.

Archive Node Providers

Node Providers make it simple for anyone to access and interact with the Ethereum Blockchain through their easy-to-use APIs. All you need to do is create a new project and then easily call JSON RPC methods with the URL they provide.

Infura

Infura is arguably the most popular Node Provider in the space. It was created by ConsenSys, the team behind MetaMask and the Truffle blockchain development framework. They’ve been around for a while, and their services are great for beginners and organizations looking to scale.

Now has free Archive Node Access
Great free pricing tier
Offers access to Layer 2 scaling solutions
Many other add-ons to fit your needs
Excellent documentation

Use Cases

Depending on the type of project you are building, there are several different technologies you could connect to a Node Provider.

Truffle / Hardhat

If you are writing smart contracts that interact with historical data, then a development suite such as Truffle or Hardhat would fit your needs. They both have an assortment of built-in tools that make the entire development lifecycle for your dApp much easier. Connecting to an Archive Node, in this case, is as easy as setting your provided API URL endpoint as a variable to be used in your frontend code.

Ganache

If you need quick access to an Archive Node for local development or testing, Truffle offers a personal blockchain that accomplishes this nicely. This blockchain is called Ganache. As of Ganache version 7.0, spinning up a local instance of the Ethereum blockchain with Archive access is as simple as one command:

ganache --fork

You could then interact with it similarly as above, using the URL: http://localhost:8545, or whatever you set the port to.

Direct Integration

If you don’t require a suite of blockchain tools, then you can use your Node Provider URL directly in your frontend code and connect to it with a JavaScript library such as ethers.js or web3.js. This is the option we will explore in the project below.

The Project

As mentioned at the start of this article, we will be making a simple “Year in Review” type app to display some wallet statistics from 2021. We will clone a pre-built frontend, so all we have to worry about is querying an archive node and then displaying the data nicely.

What we will learn:

How to get an Infura API URL with archive access
How to gather archive data using an Infura API URL and web3.js
The JavaScript required to collect the data from the blockchain
How to put the data together to display it nicely in the app

What is needed to complete the project:

Additional resources

The Infura API URL

The first step in our project is to set up our Infura account and acquire our API Endpoint URL. Head to https://infura.io/ and either create a new account or log in.

Create a new project to get the API Endpoint URL we will need later in our project.

Since archive access is now free for all users, we don’t need to complete any other steps with our Infura account.

With that out of the way, let’s start working on the frontend!

The Frontend

We will be building on top of a pre-made React frontend for the rest of this project. If you’ve never used React before, that’s okay. We will be walking through the rest of the steps together.

To install the project properly, we will use git and node package manager (npm). To see if they are already installed, we can check the version numbers in the command line:

npm --version

git --version

If they still need to be installed on your machine, you can get them at the following links:

Node / npm: https://nodejs.org/en/
Git: https://git-scm.com/downloads

Once installed, we are ready to start working on the rest of the project:

In the command line, navigate to the folder you would like to work out of and clone the repository for our project:

 git clone https://github.com/paul-mcaviney/archive-node-project-frontend.git

Change directories into the new project folder and install the required dependencies:

cd archive-node-project-frontend

npm i

After the dependencies finish installing, let’s run the project to make sure it’s working correctly so far:

npm start

If everything is installed correctly, we will now have a frontend running on http://localhost:3000 that looks like this:

There’s a text field we will use to enter a wallet address. Clicking the Submit button takes us to our results page. We can also return to the input page from here by pressing the Enter New Address button.

Before we start coding, we need to install one more dependency. We will be using web3.js to access an Archive Node with our Infura URL. To install web3.js, type the following command in the directory for our project:

npm install web3

We will do all of our coding in the App.js file under the src folder. The first bit of code we need to write is to import web3 to our project and connect it to our Infura URL. Under the import statements, and before the App function, add the following code:

const Web3 = require('web3'); 
const infuraURL = 'YOUR_INFURA_URL_HERE'; 
const web3 = new Web3(new Web3.providers.HttpProvider(infuraURL));

Note: Do not upload this project to a public repository without first hiding your actual Infura URL. You can use environment variables for this.

We’ll be using the useState React hook to update our UI. You’ll notice it’s already imported at the top of our file. Next, let’s add some React state variables to make it easier to display the data we gather from our Archive Node. Under the results state variable, add the following:

const [address, setAddress] = useState(''); 
const [currentBalance, setCurrentBalance] = useState(0); 
const [startOfYearBalance, setStartOfYearBalance] = useState(0); 
const [endOfYearBalance, setEndOfYearBalance] = useState(0); 
const [balanceDifference, setBalanceDifference] = useState(0); 
const [transactionCount, setTransactionCount] = useState(0);

Now we need to update the handleInput function to assign the user input to our address state variable instead of logging the comment:

const handleInput = event => {  
    setAddress(event.target.value); 
};

Note: You’ll notice we didn’t put any checks here to make sure what the user inputs is actually an Ethereum wallet address. This is for the sake of keeping this tutorial simple. You will want to handle this differently if deploying publicly.

The last bit of JavaScript is an asynchronous function that will gather the data from the Archive Node, convert it to more readable values, and set our state variables. Under the comment that says Your JavaScript code will go here, type the following code:

// Access and process data from Ethereum blockchain
const accessEthereum = async () => {

    // 2021 Start and End Block variables 
    const START_2021_BLOCK = 11565019;
    const END_2021_BLOCK = 13916165;

    // Get current balance of address 
    const balance = await web3.eth.getBalance(address);

    // Convert balance from wei to ETH and set state variable
    setCurrentBalance(await web3.utils.fromWei(balance.toString(), 'ether'));

    // Get wallet balance at the start of 2021 (Block #11565019)
    const startBalance = await web3.eth.getBalance(address, START_2021_BLOCK);

    // Get wallet balance at the end of 2021 (Block #13916165)
    const endBalance = await web3.eth.getBalance(address, END_2021_BLOCK);

    // Convert startBalance to ETH and set state variable
    const startBalanceAsETH = await web3.utils.fromWei(startBalance.toString(), 'ether');
    setStartOfYearBalance(startBalanceAsETH);

    // Convert endBalance to ETH and set state variable
    const endBalanceAsETH = await web3.utils.fromWei(endBalance.toString(), 'ether');
    setEndOfYearBalance(endBalanceAsETH);

    // Set balanceDifference from start to end of 2021
    setBalanceDifference(endBalanceAsETH - startBalanceAsETH);

    // Get transaction count at start of 2021 (Block #11565019)
    let startTransactions = await web3.eth.getTransactionCount(address, START_2021_BLOCK);

    // Get transaction count at end of 2021 (Block #13916165)
    let endTransactions = await web3.eth.getTransactionCount(address, END_2021_BLOCK);

    // Set total transaction count in 2021
    setTransactionCount(endTransactions - startTransactions);

    // Received results, condition met to show them on screen
    setResults(true);    

};

Moving on to the HTML, the first thing we need to do is replace the button function with the new one we just wrote. Change the function call for the button under the Change this button function comment:

<button onClick={accessEthereum} className='form-button' type='submit' name='submit' id='submit'>

The final bit of code we need is the HTML that will display the data we gathered from our Archive Node. In the return statement, scroll down to the comment that says Your HTML code will go here and add the following:

<h3>{address}</h3>

<p className='result-heading'>Current Balance</p>
<p>{currentBalance} ETH</p>

<p className='result-heading'>Start of 2021 Balance</p>
<p>{startOfYearBalance} ETH</p>

<p className='result-heading'>End of 2021 Balance</p>
<p>{endOfYearBalance} ETH</p>

<p className='result-heading'>Difference from Start of 2021</p>
<p>{balanceDifference} ETH</p>

<p className='result-heading'>Number of transactions in 2021</p>
<p>{transactionCount}</p>
<br />

To see the complete project code, check out this Github repository.

Now let’s test out our app and see if it works! First, start the app:

npm start

Enter an Ethereum wallet address to the text field and hit Submit. If you don’t have a wallet address that was active in 2021, you can use Vitalik’s.

Awesome! Our results are displayed correctly, and we can see all the activity of the wallet address in 2021!

Conclusion

By following this tutorial, you accessed the data on an Archive Node using your Infura API Endpoint URL, then displayed it nicely in a simple ETH Year in Review app.

An Archive Node is required to access data from the Ethereum Blockchain prior to the most recent 128 blocks. They store all historical state data from the very first block and serve it up much more quickly and efficiently than a Full Node. Now that Infura offers free Archive Node access to all users, gathering historical blockchain data has never been easier!

How To Mint an NFT on Polygon

Paul McAviney — Tue, 10 May 2022 22:32:28 +0000

Introduction

Non-Fungible Tokens (NFTs) have exploded in popularity over the last year. And with NFTs being used for art, PFPs, lifestyle brands, sports, games, the metaverse, and more, they won’t be going away anytime soon. But the current state of NFTs has a few problems - notably, minting on Ethereum can be prohibitively expensive and the metadata behind those NFTs is often centralized.

In this article, we’ll look at one way to solve those issues by creating and deploying an NFT to the Polygon Network and using IPFS to store the metadata. In our example, we’ll use Truffle as our development environment and Infura to connect and interact with the blockchain and IPFS.

A Quick Overview of NFTs

Fungible tokens are cryptographic tokens that can be exchanged for any other of the same token (1 == 1). These include cryptocurrencies such as Bitcoin (BTC) or ETH. One Bitcoin is exactly the same as any other Bitcoin.

In contrast, NFTs are not fungible - one token is not replaceable by another, and they may have varying values (1 != 1). An NFT is an undisputable representation of digital ownership. It can be used to represent any manner of digital property such as images, videos, music, and so much more.

NFTs on Ethereum and Layer Two

Most NFTs are created on the Ethereum Network, as it allows for the greatest sense of security and decentralization. However, for the average person, there is a major issue: Transacting on Layer 1 of the Ethereum Network is expensive.

Over the course of 2021, several solutions to this problem have gained popularity. Layer 2 solutions such as Arbitrum, zkSync, and the Polygon Network are here to provide a more user-friendly experience. Transaction fees on these networks are a fraction of what they would be on Layer 1, and in most cases, significantly faster.

Another current problem with NFTs is that the metadata they contain isn’t always stored in a decentralized manner. If the organization hosting the metadata disappears, so does the value of your NFT. The best solution is to host the metadata using a global, peer-to-peer file system such as InterPlanetary File Storage (IPFS).

Combining technologies such as Polygon and IPFS creates a cost-effective method to deploy and store your NFT in a more decentralized and permanent way. Although we could use no-code services such as those provided by ConsenSys, it’s more fun to actually deploy one yourself and you will get a better understanding of how it all works behind the scenes.

So let’s look at how you can create and deploy an NFT to the Polygon Network. We will use Truffle as our development environment and Infura to connect and interact with the blockchain, and to store the metadata with IPFS.

Before deploying, we will test on a local instance of a blockchain with Ganache. When it’s ready to go live, we will deploy to the Polygon Mumbai Test Network and will verify the NFT on OpenSea, the world’s most popular NFT platform.

The Project

What You Will Learn

Upload the NFT image and metadata to IPFS via Infura
Set up the Polygon Network in MetaMask and get test funds
Set up Truffle Development Environment
Write an NFT smart contract
Test deployment locally using Ganache
Deploy to Polygon testnet using Truffle console and Infura
Verify the NFT on opensea.io

What You Will Need

NodeJS / NPM - installation and package management
Truffle - development environment
Ganache - local blockchain instance for testing
Infura account - used to interact with IPFS and Polygon Networks
MetaMask account - supply funds to process transactions

Additional Resources

Setting Up Accounts

Before we get to the fun parts like building and testing, let’s set up our accounts and get everything in place. This will ensure the rest of the process goes smoothly.

Get an Infura Account

Infura is an Ethereum node provider and API. It will allow us to easily connect to the Polygon Network and also provides an easy-to-use method for utilizing IPFS.

The first thing we need to do is head to infura.io and set up a free account. After verifying our email address, we can access the dashboard, where we can make new projects. The Polygon Network isn’t enabled by default, however.

We can add Polygon to our plan by selecting the “Add-Ons” tab on the left-hand side of the screen and scrolling down to “Network Add-Ons”. Next, we select “Polygon PoS Add-On” and go through the prompt to add it.

Now we’re ready to create a new project. Let’s head back to the dashboard and click on the “Create New Project” button. We’ll select Ethereum as the product and name our project Polygon-NFT.

Once our project is created, there are several things to note:

The Project ID
The project secret
Endpoints selection
Our endpoint link

Let’s change our Endpoint from MAINNET to POLYGON MUMBAI, which is the Polygon testnet. Our Endpoint link will then change. We will need the values on this page later, but for now, we are done with the project page.

IPFS via Infura

Since we are already in our Infura account, let’s go ahead and create another project. This one will be for utilizing IPFS to store the image and metadata of our NFT. This time when we create a new project, we will select IPFS as the product. Let’s name this one Polygon-NFT-Metadata.

For the next steps we will need the Project ID, project secret, and endpoint URL, but first, we need an image for our NFT.

Just right-click and save this to your machine ;)

Feel free to use your own image moving forward. OpenSea recommends the image size to be 350 x 350 pixels.

Now let’s upload the image to IPFS!

Using a command terminal, we will cd into the folder where our image is stored.

To upload the image, type the following command:

curl -X POST -F file=@myfile \ -u "PROJECT_ID:PROJECT_SECRET" \ "https://ipfs.infura.io:5001/api/v0/add"

Note:

@myfile should be the name of the image file in the current folder. So in our case @polygon-nft.jpg.
PROJECT_ID and PROJECT_SECRET will be the keys provided in the settings for our Infura project.

The output from the command should look something like this:

The most important part of the output will be our “Hash”. We can actually verify the image was uploaded successfully by pasting that Hash into the following URL: https://ipfs.io/ipfs/YOUR_HASH_HERE

It’s important to note that Infura pins our data to IPFS by default. If we ever want to remove an item from IPFS we have to unpin it. Now that our image is stored on IPFS, let’s get the metadata stored there as well. According to standards by OpenSea, we will want our metadata in JSON format like so:

{ 
  "name": "My Sweet Polygon NFT",   
  "description": "Our amazing NFT deployed to the Polygon Network",     
  "image": "ipfs://YOUR_HASH_HERE" 
}

So let’s create a new text file in the same folder on our local machine as our NFT image. We can use any text editor for this; it doesn’t need to be anything fancy.

We’ll add the metadata in the same format as above. However, rather than using YOUR_HASH_HERE we’ll insert the actual Hash for our image that we just verified. We’ll save the file as nft-metadata.json. We also need to make sure there is no comma after the last item in our JSON file. If there is a comma, then OpenSea will not display the NFT properly.

Now we can add this file to IPFS using the same command as last time; we just need to replace the file name with @nft-metadata.j.

Excellent! We now have our metadata pinned to IPFS which has a link that points to our already pinned image. We’ll copy the Hash in the output to use later.

Setting Up MetaMask

In order to interact with the Polygon Network and to pay any transaction fees, we will need to set up a Web3 wallet. We will use MetaMask to do this. It is installed as a browser extension and allows us to connect to Decentralized Apps (dApps).

Let’s head over to metamask.io and download the extension for our browser. When using a crypto wallet like MetaMask, it’s a good idea to understand wallet safety.

Remember: Never share your seed phrase with anyone! Whoever has your seed phrase can withdraw your tokens.

We will need to use the 12-word seed phrase when setting up our Truffle project. So be sure to write that down and save it for later. Once we install MetaMask and open it to the dashboard, we need to add Polygon to our Networks dropdown.

When we click the dropdown, it reveals a button to add new networks to the list. So we’ll press the “Add Network” button, and add both the Polygon Mainnet and Mumbai Testnet.

We will need to enter in the following information:

Mumbai Testnet

Network Name: Mumbai (Polygon Testnet)
New RPC URL: https://rpc-mumbai.maticvigil.com/
Chain ID: 80001
Currency Symbol: MATIC
Block Explorer URL: https://mumbai.polygonscan.com/

Polygon Mainnet

Network Name: Polygon Mainnet
New RPC URL: https://polygon-rpc.com/
Chain ID: 137
Currency Symbol: MATIC
Block Explorer URL: https://polygonscan.com/

Now we have the Polygon Network added to our MetaMask, but if we switch to the Mumbai Testnet, there’s no MATIC! Let’s change that. We’ll need to copy our wallet address, which is listed under the name of our Account. It starts with 0x…

Next, we’ll head over to https://faucet.polygon.technology/ which is a faucet that provides test funds for development. We need to select the Mumbai Network and then paste our address into the text field. Once we hit “Submit” we should see some MATIC tokens in our MetaMask wallet after a minute or two.

Note: If you have multiple accounts in your MetaMask wallet, Truffle uses the first one by default. So be sure to add the test MATIC tokens to the first account in your list.

Now that we have loaded our wallet with some test tokens, we are ready to move on.

Install Truffle and Ganache

Truffle

Truffle is a development environment that provides tools to make building on the blockchain much easier. In order to install it via the command line, we will need NodeJS v8.9.4 or later and Node Package Manager (npm). If it’s not already installed, check out this link.

Once it’s installed on our machine, we can install Truffle using this command in the terminal:

npm install -g truffle

We can type the command truffle version afterward to ensure it was installed correctly. If there are any errors, be sure to add the npm modules to your path.

Ganache

Next we’ll install Ganache, a local blockchain instance used for testing before deploying to the Mumbai Testnet.

Ganache has a GUI version that can be downloaded here, but we will use the terminal version for the rest of this tutorial. It can be installed using this command:

npm install ganache --global

Again, we can verify proper installation by checking the version: ganache --version

Setting Up Our Project

Now that our accounts are set up and everything is installed properly, let’s start putting it all together. The first step is to navigate in our terminal to where we want to create our project and make a new directory.

mkdir polygon-nft-project && cd polygon-nft-project

One incredibly useful thing about Truffle is they offer a full suite of “boxes” for getting started quickly. They are essentially boilerplates that include helpful modules, pre-made smart contracts, frontend views, and more. For this project, we will utilize Truffle’s Polygon Box. Installation is simple; we just need to type this command:

truffle unbox polygon

After installation, we can see there are several new files in our project folder. The most important ones we will be working with are the README.md file, truffle-config.polygon.js, the 1_deploy_simple_storage.js under the migrations folder, and SimpleStorage.sol files, which can be found in the contracts folder.

You will likely see an ethereum and polygon folder under contracts. This is because typically when a project is deployed to Polygon, it should also be deployed to Ethereum so users can easily bridge their assets back and forth. We can delete the SimpleStorage.sol contracts since we won’t be using them.

Taking a quick glance through the README.md file, we can see that in order to deploy to the Polygon Network, we will have to add two things:

The Mnemonic phrase (seed phrase) of the wallet we are using
The Infura Project ID

We’ll want to store these in a .env file and make sure it’s added to our .gitignore so we don’t accidentally upload these secrets if storing our project on a public repository.

Downloading the Polygon Truffle Box also installed the .dotenv package for us. All we need to do is create a .env file in our root folder.

The mnemonic phrase for our wallet can be found in our MetaMask settings under the “Security & Privacy” heading. The Project ID can be found under the “Keys” heading in our Infura project settings. Our .env file will look something like this:

MNEMONIC="your twelve words here ..."
INFURA_PROJECT_ID="project ID # here"

The next thing we should do is update Truffle to use the latest version of Solidity. In our truffle-config.polygon.js file, we can add the compiler version we wish to use.

Under the compilers section, within the solc curly braces, we’ll add the following: version: “0.8.11” (the latest version of Solidity at the time of this writing).

It should look like this:

// Configure your compilers
compilers: {
    solc: {
        version: "^0.8.11"
    }
},

Note: If you didn’t delete the SimpleStorage.sol contracts, then you will need to update their Solidity version in order to compile properly. Simply change the pragma line to the following: pragma solidity >=0.4.21 <0.9.0;

The last bit of prep work is just to install the OpenZeppelin contract library, as we will import several contracts. We can install it by typing this command in the root directory of our project:

npm install @openzeppelin/contracts

We are utilizing the OpenZeppelin library to make writing our smart contract easier and much safer. The contracts we will use have had thorough security audits and it ensures we are adhering to the industry standard for NFTs.

With our project set up properly, we are ready to get to the best part… Creating the NFT!

The Smart Contract

We will open up our preferred code editor from our project root folder. (I’m using vscode so the command is code ..) Create a new file under the contracts folder named PolygonNFT.sol.

Note: If you need to brush up on the Solidity coding language, check out my Solidity Basics Series.

We’ll be using the following smart contract for our NFT:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;

// Import the OpenZeppelin contracts
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

// Declare our contract and inherit from the OpenZeppelin ERC721 and Ownable contracts 
contract PolygonNFT is ERC721, Ownable {
    // Helpers for counting safely and converting data to strings
    using Counters for Counters.Counter;
    using Strings for uint256;

    // State variable for storing the current token Id
    Counters.Counter private _tokenIds;
    // Map token Ids to token URI
    mapping (uint256 => string) private _tokenURIs;

    // ERC721 requires a name for the NFT collection and a symbol
    constructor() ERC721("PolygonNFT", "PNFT") {}

    // Set the URI (metadata) for tokenId
    function _setTokenURI(uint256 tokenId, string memory _tokenURI)
        internal
        virtual
    {
        _tokenURIs[tokenId] = _tokenURI;
    }

    // Return the Token URI - Required for viewing properly on OpenSea
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(tokenId), "Token does not exist");
        string memory _tokenURI = _tokenURIs[tokenId];

        return _tokenURI;
    }

    // Mint the NFT to the provided address, using the provided metadata URI -- only the wallet address that deployed this contract can call this function
    function mint(address recipient, string memory uri)
        public
        onlyOwner
        returns (uint256)
    {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();

        _mint(recipient, newItemId);
        _setTokenURI(newItemId, uri);

        return newItemId;
    }
}

Pretty short, right?! That’s the beautiful thing about the composability of Web3. OpenZeppelin is doing most of the heavy lifting here with their ERC721 standard.

Basically, we are simply defining the NFT collection and symbol, supplying the NFT metadata via the _setTokenURI() function, putting it together with our mint() function, and then providing a way for OpenSea or anyone else to retrieve the NFT metadata through our tokenURI() function.

Testing Deployment With Ganache

Deploying to the blockchain is pretty simple, but before we can do that, we need to modify the 1_deploy_simple_storage.js file under the migrations folder. We just need to replace every instance of SimpleStorage with whatever we named our NFT smart contract. In our case: PolygonNFT. We should also rename the file to 1_deploy_polygon_nft.js to eliminate any confusion.

Our migration file should now look like this:

const PolygonNFT = artifacts.require("PolygonNFT"); 

module.exports = function (deployer) { 
    deployer.deploy(PolygonNFT); 
};

Before deploying our project to a live blockchain, it is common practice to test it on a local blockchain instance. We will use Ganache to do this. In a new terminal window, we will use this command to get it up and running:

ganache

The terminal should output some Available Accounts, their Private Keys, and so on.

To deploy our project to Ganache, open up the original terminal window. In the root directory of our project, type the command:

truffle migrate --config=truffle-config.polygon.js --network=development

Since there are two config files in our project, we need to specify which one to use. Truffle will use the truffle-config.js file by default. After hitting enter, we can see that Truffle compiles our contracts and then starts the migration. If all goes successfully, you will receive a transaction receipt that will look something like this:

Take note of the contract address

Now that our contract has migrated successfully to our local blockchain instance, we can use the Truffle Console to interact with it. The Truffle Console is a powerful tool that allows us to use javascript to interact directly with our contract without having to set up a frontend. To use it, type the command:

truffle console --config=truffle-config.polygon.js --network=development

Notice how the command prompt changes to truffle(development)>. We are now ready to start interacting with our smart contract.

First, we need to get an instance of our contract. Copy the contract address from our transaction receipt to be used in this line of code:

let instance = await PolygonNFT.at("YOUR_CONTRACT_ADDRESS_HERE")

It will return undefined but if we type instance it should output our contract ABI. Now we can call the mint function. We will need a contract address in which to send the NFT and our IPFS URI from earlier in the format: ipfs://YOUR_HASH_HERE

await instance.mint("YOUR_WALLET_ADDRESS", "YOUR_METADATA_URI")

It’s important to note that the mint function is being called by the address that deployed the contract because that is the one we logged into the Truffle Console with by default. The address we placed in the code above is the recipient of the NFT.

If all went well with our code above, we shouldn’t see any errors after we hit enter! We now know our contract works and we are able to mint an NFT from it. Unfortunately, since this is a local blockchain instance, we don’t have OpenSea or PolygonScan to verify that our NFT actually exists. For that, we will deploy to the Mumbai Testnet.

Deploy to Polygon Testnet

The process to deploy to the Mumbai Testnet is very similar to launching on our Ganache blockchain instance. We just need to exit the Truffle console by typing ctrl+c twice and then follow the exact same steps as above. The only difference is we will replace the network= development with polygon_infura_testnet.

Before moving forward, we need to make sure our Mnemonic phrase and Project ID are set up properly in our .env file otherwise, the next steps won’t work. (See the steps in the Setting Up Our Project section.) With those in place, our commands will now look like this:

truffle migrate --config=truffle-config.polygon.js --network=polygon_infura_testnet

The migration will take a little bit longer than our Ganache instance. Once it’s complete it will output a transaction receipt that looks similar to our last one. This time we can verify that our contract was successfully migrated to the Mumbai Testnet by entering our contract address to https://mumbai.polygonscan.com/address/YOUR_ADDRESS_HERE

Excellent! Our contract is live on the Mumbai Testnet! Now let’s interact with it and actually mint our NFT!

We’ll access the Truffle Console using the same commands as before, again, replacing the network= development with polygon_infura_testnet.

truffle console --config=truffle-config-polygon.js --network=polygon_infura_testnet

Get an instance of our contract using the contract address that was output on our Mumbai Testnet transaction receipt:

let instance = await PolygonNFT.at("YOUR_CONTRACT_ADDRESS_HERE")

And now, for the moment we’ve been building towards this entire article! Mint our NFT to our desired address using our IPFS URI in the format: ipfs://YOUR_HASH_HERE

await instance.mint("YOUR_WALLET_ADDRESS", "YOUR_METADATA_URI")

If there aren't any errors, we can check our contract on mumbai.polygonscan again and see that our mint() function was called! This time, we can verify that our NFT actually exists by checking it out on OpenSea.

Verify Our NFT On OpenSea

We can easily check out our new NFT on OpenSea by copying our contract address into the search bar at https://testnets.opensea.io/. Ethereum addresses have two versions, one that is checksummed and one that is not. The difference being the non-checksummed version is all lowercase. We may need to use the non-checksummed version to find our NFT on OpenSea. We can get this address by clicking on the Txn Hash on mumbai.polygonscan and then copying the address across from Interacted With (To):

Your contract address will be different

If our metadata was entered correctly we should now see our beautiful, new NFT live on OpenSea!

Conclusion

Congratulations! You have successfully deployed an NFT to the Polygon Mumbai Testnet! You uploaded your NFT image and metadata to IPFS using Infura’s API, set up your Truffle project and wrote a smart contract to create an NFT, tested deployment locally using Ganache, deployed to the Polygon Testnet with Truffle, Infura, and MetaMask, and finally, verified your NFT on OpenSea.

You now have the knowledge to deploy to the Polygon Mainnet, just make sure you have real MATIC tokens in your MetaMask wallet. Additionally, when deploying, be sure to use network=polygon_infura_mainnet instead of polygon_infura_testnet.

Your next steps would be to deploy to the Ethereum Mainnet to be able to bridge your NFT from Layer 2 to Layer 1. That is the topic for another article so be sure to check out the Polygon Docs in the meantime.

Thank you for following along with this tutorial! Take care, and happy building!

(The code for this project can be found here: https://github.com/paul-mcaviney/polygon-nft-project)

Forem: Paul McAviney

Get Started on Celo with Infura RPC Endpoints

What is Celo?

Mapping Phone Numbers to Public Keys

Paying Gas Fees with ERC-20 Tokens

The Network is Carbon Negative

Why Use Celo with Infura?

Summary

How to Run Ganache in a Browser

Ganache in the Browser

The Project

Requirements

Step 1 – Installation

Step 2 – Set Up the Project

Step 3 – Write the Smart Contract

Step 4 – Deploy to Ganache

Step 5 – Build the Frontend

5.a – Setup

5.b – The Frontend Code

5.c – Run the Project

Step 6 – Fork Goerli or Mainnet with Ganache in the Browser

Conclusion

Infura’s Plans To Launch A New Decentralized Infrastructure Protocol And Why It Matters

Introduction

Decentralized Protocols

What is a Decentralized Infrastructure Protocol?

Why is Decentralized Infrastructure Important?

What Can You Do?

How Does Polygon Help Ethereum Scale?

Introduction

The Problem with Ethereum

The Solution

Introducing Polygon

A Note on Polygon PoS Security

Comparison in Action

Overview of the NFT Project

Creating the NFT Contract

Step 1: Install the MetaMask Extension

Step 2: Add Goerli and Mumbai Chains to MetaMask

Step 3: Get GoerliETH and Mumbai MATIC from a Faucet

Step 4: Install NPM and Node

Step 5: Create a Node Project and Install Dependencies

Step 6: Writing the Smart Contract

Step 7: Deploy the Contract Locally

Step 8: Deploy the Contract to Goerli

Step 9: Deploy the Contract to Mumbai

Comparing Cost and Time

Ethereum

Polygon

Conclusion

No-Code: Buy Me a Coffee With Coinbase!

Introduction

The Problem: Broke But Still Building

The Solution: No-Code With Coinbase Commerce

How to Install a Crypto Donations Button

What You’ll Learn

What You’ll Need

Additional Resources

Step 1 - Set Up a Coinbase Commerce Account

Step 2 - Whitelist Your Website

Step 3 - Create a Checkout

Step 4 - Add the Code to Your Website

Conclusion

Using Infura’s NFT API With Lootbox

Introduction

What is the Infura NFT API?

Infura NFT API Capabilities

The Lootbox Project

Step 1 - The Infura Project ID and Secret

Step 2 - MetaMask

Step 3 - Setting Up The Project

Step 4 - The Lootbox Code

Step 5 - Running The Lootbox Project

Conclusion

Accessing Ethereum Archive Nodes with Infura

Introduction

Table of Contents

What Are Ethereum Nodes?

Types of Ethereum Nodes

Full Node