Infrastructure is essential

Infrastructure is simply the building blocks or foundation of any system. Complex systems need a suitable infrastructure to function efficiently. Infrastructure is a very important topic in Web3.

Building on blockchains such as Ethereum, Polygon, Avalanche, and Fantom requires a lot of resources if one intends to set up their own infrastructure from scratch. For example, you would need to set up a node which can be expensive and time-consuming.

Today, we now have infrastructure providers that provide developer tools, APIs, node functionalities, and data access so that developers/builders are able to concentrate more on their products and are able to ship their dApps faster. On your preferred blockchain, you get to easily build and operate full nodes and validator nodes usually in pretty simple steps.

This topic was inspired by my personal usage and interaction with some infrastructure providers. In no particular order, here is a review of some of the best Web3 infrastructure providers alongside their features, products, and pricing.

Infura

Infura simplifies blockchain development by bringing all of your tools together in one place: Ethereum Nodes, Eth2 Nodes, Transaction Relaying, Layer 2 Networks, IPFS, Filecoin, and more.

Infura Products

• Ethereum API: The Infura API suite gives rapid access to the Ethereum network through HTTPS and WebSockets.

• IPFS API and Dedicated Gateway: Infura's IPFS API and dedicated gateway, designed for speed and simplicity, links apps of all sizes to distributed secure storage, paving the path for more resilience online.

• Infura Transactions (ITX): ITX is the simplest method to submit an Ethereum transaction; simply choose your budget, fill your tank, and let them discover the cheapest gas pricing for you.

Infura Pricing

Infura's pricing fits per app and app usage. There are also custom plans with bulk savings, service level agreements, and limitless projects.

For the Ethereum API, there is a free plan that supports up to 3 projects and 100,000 Requests per Day as well as the developer plan which supports 10 Projects and 200,000 Requests per Day for $50/month. Other plans are also available such as the team and growth plan.

For the IPFS API & Dedicated Gateway, there is a free plan with up to 5GB of storage and 5GB data transfer up as well as the Plus plan which is billed per usage with unlimited storage at $0.08/GB and unlimited data transfer at $0.12/GB.

Ankr

Ankr offers a genuinely distributed and decentralized Web3 architecture for running node services. Ankr Build is a completely distributed, multi-chain infrastructure network and toolset that simplifies application development. Ankr currently supports the following chains: Arbitrum, Avalanche, Binance Smart Chain, Celo, Ethereum, Fantom, Gnosis, Harmony, IoTex, Moonbeam, Near, Nervos, Polygon and Solana

Ankr Products

• Public Community RPC APIs: The Ankr Protocol network is topped by the Public RPC Layer.

• Ankr Scan: Ankr Scan is a Multi-Chain Explorer that allows you to see assets from several chains as well as those tied to a single wallet address. Think EtherScan but for multiple chains.

• Node Services: For 50+ chains, full, archive, and validator/staking nodes are accessible on Ankr.

Ankr Pricing

Ankr offers adjustable options and price plans to fit all budgets and needs.

The Public RPCs are free to use with an offer of access to Full and Archive Data, a soft limit of 1M requests per day, and HTTPS connection. The Premium RPCs cost about 10000 ANKR(approximately $717.44) with unlimited rate limit, unlimited requests, HTTPS and WebSockets connection, and Global node coverage.

There are several API pricing plans such as the free plan with a 20 rate-limit per second and 170,000 Requests per day. There is also the basic plan which costs about $49/month for access to 200 rate-limit per second, 1M Requests per day and the builder plan which costs about $224/month for access to 600 rate-limit per second and 5M requests per day.

QuickNode

QuickNode makes it simple to power blockchain apps and scale-up business by providing elastic APIs, sophisticated tools and analytical tools. QuickNode currently supports the following chains: Binance Smart Chain, Ethereum, Arbitrum, Optimism, Avalanche, Fantom, Luna, Solana, Algorand, Terra, Gnosis, Polygon and Celo.

QuickNode Products

• QuickNode APIs: QuickNode provides either a dedicated endpoint that always serves traffic from the same location as specified when the endpoint was launched or access to their global network, which always routes traffic to the nearest available endpoint.

• NFT API: Without having to filter through individual smart contracts, QuickNode's NFT API allows you to discover any NFT, verify ownership, and retrieve transaction history and key collection information.

QuickNode Pricing

QuickNode provides a 7-day free trial plan known as the Launch plan after which a fee of $9/month is required and it gives access to Domain Masking, Analytics, HTTP Endpoint, and Rate Limits of 150k responses per day. There is also the Build plan which costs $49/month for rate limits of unlimited responses per day, support response within 12 hours together with Domain Masking, Analytics, HTTP Endpoint, and URL Whitelisting.

The Scale plan and Enterprise/Custom plans are also available. The Scale plan costs $299/month. If you also need a private blockchain cloud, QuickNode can provide it.

Moralis

Moralis offers a unified approach for developing high-performance dApps and compatibility with favorite web3 tools and services. Consider Moralis as Firebase but for Web3. Moralis offers managed backend services for blockchain applications. Moralis currently supports the following chains: Ethereum, Binance Smart Chain, Polygon, Arbitrum, and Avalanche.

Moralis Products

• Moralis Web3 SDK: The Moralis JavaScript SDK is the means via which the builder's dApp will communicate with the Moralis Server. The SDK may be used to access and set user data in order to get balances, NFTs, events, or transactions. It supports crypto login and user management, IPFS integration and dApp hosting.

• Moralis Web3 API: Moralis Web3 API is a sophisticated blockchain API that allows you to query data from any chain. The Web3 API can be called using the Moralis SDK with just a few lines of code.

• Speedy Node API: Speedy Nodes have the same functionality as regular Ethereum, Polygon, or BSC nodes, but they are faster, more reliable, and completely integrated with all Moralis services.

Moralis Pricing

The free plan is called the Starter Plan and is very suitable for people that are just starting off with blockchain development. It offers free access to unlimited plugins, IPFS Gateway, and community support with 10M requests per month using Speedy Nodes + Moralis API.

For blockchain professionals, there is the Pro plan that costs $49 per month with access to everything in the free plan with more requests, a higher Rate Limit, and email support with 25M requests per month using Speedy Nodes + Moralis API.

For larger teams, there is the Enterprise plan with custom requests per month, SLAs, and premium chat support (Phone, Chat, Email).

Alchemy

Alchemy powers some of the top Web3 applications that are existing today. Alchemy gives the capabilities of a node and a no-configuration in-house set of developer tools for quicker prototyping, debugging, and shipping of dApps. Alchemy currently supports the following chains: Ethereum, Polygon, Arbitrum, Optimism, Flow, StarkNet and Crypto.org.

Alchemy Products

• Alchemy Supernode: Alchemy Supernode's revolutionary web3 design amplifies every piece of node capability with separate distributed systems and ensures real-time data accuracy using a proprietary coordinator service.

• Alchemy Notify: Alchemy Notify provides the UX builders expect and need. Alchemy Notify allows users to deliver appropriate, timely alerts on the most significant Web3 events such as notifications for mined transactions, dropped transactions, and smart contract events which are integrated.

• Alchemy Build: Alchemy Build is a no-configuration in-house developer tool package that allows you to prototype, debug, and release products more quickly. Alchemy Build allows you to quickly prototype and fix unsuccessful requests with instant UI feedback.

• Alchemy Monitor: Alchemy Monitor is an all-in-one dashboard and alarm system for app health, performance, and user behavior.

• Enhanced and Chain APIS: Alchemy provides access to improved API methods for returning block and transaction requests, smart contract event logs, and pending transactions in a virtual mempool. Furthermore, access to updated WebSockets that are continually listening for changes and manage reconnection and backfilling missing events automatically.

Alchemy Pricing

Alchemy provides the free tier plan which gives free access to Supernode, Build, Monitor, Notify, Enhanced APIs, No Daily Request Limits, Full Archive Data and supports up to 5 apps.

The Growth plan costs about $49/month with access to everything in the free plan together with Auto-Scaling Compute Units, Parity Trace and Geth Debug, 2x Higher Throughput and supports up to 15 apps.

The Enterprise plan includes access to everything in the Growth plan plus Committed Use Discounts, Custom SLAs, Custom Throughput and supports an unlimited number of apps.

With that, we have come to end of my review! I recommend that you try out any of them that suits your needs! Happy hacking and building😁! LFG🚀🚀🚀! WAGMI🚀🚀!

Oracles are data feeds that connect blockchains to off-chain, real-world information so that you can query data in your smart contracts. Your smart contracts will be able to execute based upon inputs and outputs from the real world. They typically provide a way for web3 ecosystems to access existing data sources and advanced computations. They are very useful for data analysts, data providers and data users.

DIA Oracle

One of such existing oracle is the DIA oracle. DIA provides a reliable and verifiable bridge between off-chain data from various sources and on-chain smart contracts that can be used to build a variety of financial dApps. There are quite a number of things you can do with DIA. You can develop applications and sources on top of DIA. In this article, I would be creating a simple app that displays ETH/USD price. Presently, DIA allows you do several other pairs such as BTC, DIA, USDC, FTM, SDN, KSM, MOVR which are all USD based.

Time to code Let's get to code, shall we! I will be using javascript and html for this.

Create/Navigate to your project folder:

mkdir pricefeed
cd pricefeed

Now create index.html and index.js files:

touch index.html
touch index.js

I will be using one of DIA's deployed contracts. For this writeup, I would be using the smart contract address deployed on Binance mainnet.

Nagivate to the contract tab on bscscan

Here is the contract's source code

pragma solidity 0.7.4;                                                                                                                                                                                                                      

contract DIACoinmarketcapOracle {                                                  
    mapping (string => uint256) public values;                                     
    address oracleUpdater;                                                         

    event OracleUpdate(string key, uint128 value, uint128 timestamp);              
    event UpdaterAddressChange(address newUpdater);                                

    constructor() {                                                                
        oracleUpdater = msg.sender;                                                
    }                                                                              

    function setValue(string memory key, uint128 value, uint128 timestamp) public {
        require(msg.sender == oracleUpdater);                                      
        uint256 cValue = (((uint256)(value)) << 128) + timestamp;                  
        values[key] = cValue;                                                      
        emit OracleUpdate(key, value, timestamp);                                  
    }                                                                              

    function getValue(string memory key) public view returns (uint128, uint128) {
        uint256 cValue = values[key];                                              
        uint128 timestamp = (uint128)(cValue % 2**128);                            
        uint128 value = (uint128)(cValue >> 128);                                  
        return (value, timestamp);                                                 
    }                                                                              

    function updateOracleUpdaterAddress(address newOracleUpdaterAddress) public {
        require(msg.sender == oracleUpdater);                                      
        oracleUpdater = newOracleUpdaterAddress;                                   
        emit UpdaterAddressChange(newOracleUpdaterAddress);                        
    }                                                                              
}

Scroll down to also find the contract's ABI as we would be using it shortly.

Now looking at the contract, there is a getValue method, in order to get the response from the method, make a call to the method as shown below. Remember also that we are using the key ‘ETH’

Your code should look like this

const currentPriceResponse = await contract.methods.getValue('ETH').call()

Copy the ABI as we would also be using it in our code. In the end, your js file would look something close to this

async function connect() {
    const priceElem = document.querySelector('#price')
    try {
        priceElem.textContent = 'Updating price...';

        const ABI = [ABI]

        const web3 = new Web3(new Web3.providers.HttpProvider("https://bsc-dataseed.binance.org/"))
        const contract = new web3.eth.Contract(ABI);
        contract.options.address = "0xbAFEe71d40baBC12a3D0B2b8937ee62D3A070835";
        const currentPriceResponse = await contract.methods.getValue('ETH').call()
        console.log(currentPriceResponse[0]);
        if (currentPriceResponse[0]) {
            const formatter = new Intl.NumberFormat('en-US', {
                style: 'currency',
                currency: 'USD',
                minimumFractionDigits: 2,
            });
            priceElem.textContent = formatter.format(currentPriceResponse[0] / 100000);
        }

    } catch (e) {
        priceElem.textContent = 'An error occurred while updating the price, please refresh your page.';
    }
}

window.onload = function() {
    connect();
}

Let's give some edits to the index.html file. You can write something as simple as a div or a header.

<h5>
    <span>Current Value: <i id="price"></i></span>
</h5>

Run your app and you would see that you are getting ETH/USD prices in real time. That’s pretty much it! A sample is deployed here. Feel free to check out the Source Code.

Thanks for reading! I hope you learnt a thing or two.