DEV Community: Lauren Dutton

EIP-6963: Simplifying Wallet Integration for Web3 Developers

Lauren Dutton — Wed, 17 May 2023 21:22:34 +0000

Developers in the world of Web3 face challenges when integrating wallets into their decentralized applications. The traditional method of injecting Ethereum providers into the window.ethereum object can create conflicts and limit user choices, ultimately degrading the user experience. Ethereum Improvement Proposal 6963 (EIP-6963) was introduced to address these issues. This proposal offers a standardized solution utilizing window events for seamless communication between Ethereum libraries and injected scripts. By implementing EIP-6963, developers can streamline wallet integration, enhance user choice, and ensure compatibility among different wallets, thus enabling seamless interoperability across the Web3 ecosystem.

Streamlining Wallet Integration:
EIP-6963 introduces a mechanism that simplifies the integration of various wallet options into decentralized applications (dApps). This standardized approach eliminates conflicts and empowers developers to offer multiple wallet choices to users. With EIP-6963, wallet integration becomes a user-friendly and seamless experience, allowing developers to focus on building innovative dApps.

Lowering the Barrier to Entry:
One significant impact of EIP-6963 is its ability to reduce the complexity associated with integrating wallets into Web3 applications. This simplification lowers the barrier to entry for new developers entering the blockchain space. It enables them to easily incorporate blockchain functionality into their applications without the intricacies of wallet integration. As a result, more developers can effortlessly enter the Web3 arena, fostering growth and innovation within the ecosystem.

Enhanced User Onboarding to Web3:
EIP-6963 plays a crucial role in improving the onboarding experience for users entering the world of Web3. By allowing users to select their preferred wallet provider, they gain control and flexibility over their interactions with Ethereum networks. This enhancement makes the overall user experience more intuitive and accessible, especially for newcomers navigating and interacting with dApps. Users have the freedom to choose and utilize multiple wallets, enabling a personalized and flexible experience.

Promoting Interoperability:
EIP-6963's emphasis on interoperability has a transformative impact on the Web3 ecosystem. By enabling seamless interactions between different wallets and decentralized applications, collaboration and innovation among wallet providers are encouraged. This fuels the development of new features and services, ultimately strengthening the Web3 ecosystem and driving the adoption of decentralized applications.

Ethereum Improvement Proposal 6963 (EIP-6963) brings significant benefits to Web3 developers by providing a standardized solution that simplifies wallet integration, enhances user onboarding, and promotes interoperability within the ecosystem. With EIP-6963, developers can seamlessly integrate multiple wallet providers, fostering fair competition and expanding user choices. This streamlined integration process empowers developers to focus on building innovative dApps, while users benefit from a more accessible and user-friendly Web3 experience.

Authors of EIP-6963: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Micah Zoltu (@MicahZoltu), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo)

Leveraging the Infura Dashboard for Project Analytics

Lauren Dutton — Wed, 17 May 2023 18:21:07 +0000

Infura equips developers with a comprehensive dashboard that provides invaluable insights and statistics. This article will give an overview of each component of the Infura dashboard, highlighting the data they represent and demonstrating how leveraging this information can optimize project efficiency and performance.

1. Requests Volume:
The Requests Volume component on the dashboard showcases the total volume of requests sent to Infura within the selected time period. This metric provides a comprehensive overview of your project's demand and usage patterns. Look for patterns, spikes, or dips in request volumes. Compare the volume data across different time periods to identify growth trends, seasonal fluctuations, or sudden changes that may require further investigation.

2. Network Requests Volume:
The Network Requests Volume component reveals the breakdown of aggregate request volumes for the top five networks utilized in your project. This granular data offers insights into the specific networks experiencing the highest traffic. By understanding the demand distribution across different networks, you can identify potential performance issues, or congestion allowing you to optimize network selection or allocate additional resources strategically. The Infura Dashboard also monitors network outages and can be checked at status.infura.io

3. Method Request Volumes:
The Method Request Volumes component provides a detailed breakdown of the aggregate request volumes for the top five methods used on each network within your project. This data allows you to delve into the most frequently utilized methods. By closely monitoring these volumes, you can gain insights into usage patterns, optimize code and gas consumption for commonly used methods, and even explore opportunities for cost reduction and transaction efficiency.

4. Requests Activity:
The Requests Activity component presents a comprehensive breakdown of the total request volumes, successful requests, and failed requests based on networks and methods used within your project. This information is crucial for monitoring the health and performance of your dapp. By having insight into failed requests, you can promptly spot any potential issues. This real-time feedback enables you to take proactive measures to rectify errors, optimize performance, and deliver a seamless user experience.

5. Eth_call Activity:
Eth_call Activity component focuses on the eth_call method, which serves as the primary means to access already mined data from the blockchain about a particular smart contract. Analyzing eth_call activity can provide deeper insights into the requests youre making to the blockchain, integrate external data and monitor contract interactions. Identify the frequency and nature of these interactions This empowers you to make informed decision and optimize the performance and security of your dapp.

How to put this data to work:

Optimization: Analyze the data from Requests Volume, Method Request Volumes, and Network Requests Volume to identify performance bottlenecks, optimize code, and allocate resources effectively, resulting in improved project responsiveness.
Scalability: Utilize Requests Volume to plan for peak usage periods and ensure your project can scale seamlessly to meet increased demand, guaranteeing a consistently smooth user experience.
Error Handling: Monitor Requests Activity to identify failed requests and take prompt action to diagnose and rectify errors, minimizing disruptions and optimizing project reliability.
Cost Optimization: Analyze Method Request Volumes to optimize gas consumption, transaction costs, and identify areas for efficiency improvement, resulting in cost savings for your project.
Network Selection: Utilize Network Requests Volume to make informed decisions when selecting networks, ensuring optimal performance, and minimizing potential network-related issues.

Infura's dashboard provides developers with many insights into project performance and usage patterns. By leveraging the data available in your dashboard, you can make informed decisions, optimize performance, and scale your decentralized application.

Deploy NFT Smart Contracts without Solidity

Lauren Dutton — Mon, 15 May 2023 20:36:08 +0000

If your new to web3, or just getting started with Solidity, building out an end to end ERC721 or 1155 smart contract to deploy your NFT collection is no easy feat. In this blog post, we'll explore how you can use Infura's NFT API/SDK to deploy collection using exclusively javascript.

Supported Networks:
Infura's NFT SDK supports various networks, including Arbitrum, Avalanche (C-Chain), Ethereum, Palm, and Polygon. It's important to note that the write operations on the Palm Testnet network are only supported by the SDK, while read operations can be performed using REST APIs.

Getting Started:
Before diving into the code, make sure you have the latest version of Node.js installed on your system. Once that's done, let's initialize a new project and install the necessary libraries.

Get Test Funds:
Head over to faucet.infura.io to grab some Sepolia ETH, we're going to need it to deploy our contract.

Create a new project directory:

mkdir new_project
cd new_project
npm init -y

Install the required libraries:

npm install -S @infura/sdk
npm i dotenv

Create a .env file:
Create a .env file in the project root directory and add the following data:

INFURA_API_KEY=<API-KEY>
INFURA_API_KEY_SECRET=<API-KEY-SECRET>
WALLET_PUBLIC_ADDRESS=<WALLET-PUBLIC-ADDRESS>
WALLET_PRIVATE_KEY=<WALLET-PRIVATE-KEY>

Replace the placeholders with your own Infura project credentials, and add a wallet address and its private key for testing on the supported network.

Create your ContractURI:
This will just be a link to a pinned chunk of json code that tells our program what the metadata of your collection looks like. From the example below mine looks like this:
{
"description": "jet",
"image": "https://gateway.pinata.cloud/ipfs/QmWtgDewkagKn7ZYTFyHfkJ3uYCnmL3gfdWdSQpXs4VCaN/jet_img3.png",
"name": "my airplane nft"
}
and the image links to a picture of an airplane. My metadata indicates that there is only 1 token in the collection, but you can keep adding to the json file for each token as long as they are unique.

Code Implementation:
Now that we have the project set up and the required libraries installed, let's dive into the code.

// Import the libraries and load the environment variables.
const { SDK, Auth, TEMPLATES } = require('@infura/sdk');
require('dotenv').config();

// Create Auth object
const auth = new Auth({
  projectId: process.env.INFURA_API_KEY,
  secretId: process.env.INFURA_API_KEY_SECRET,
  privateKey: process.env.WALLET_PRIVATE_KEY,
  rpcUrl: process.env.RPC_URL,
  chainId: 11155111,
});

// Instantiate SDK
const sdk = new SDK(auth);

async function deployContract() {
  try {
    const newContract = await sdk.deploy({
      template: TEMPLATES.ERC721Mintable,
      params: {
        name: 'Airplanes',
        symbol: 'JET',
        contractURI: 'https://gateway.pinata.cloud/ipfs/Qmbta8RRbdXjyvXwkuqmbsXkZ8ZRoMezNsP7g6n9Db1Mx1',
      },
    });
    console.log('Contract address:', newContract.contractAddress);
  } catch (error) {
    console.error('An error occurred:', error);
  }
}

deployContract();

Explanation:
The code above demonstrates a basic implementation using Infura's NFT SDK. First, we import the necessary libraries and load the environment variables from the .env file. The Auth object is then created using the provided credentials.

Next, we instantiate the SDK with the Auth object. Inside the deployContract function, we make use of the sdk.deploy method to deploy a new NFT contract. We specify the template as TEMPLATES.ERC721Mintable and provide additional parameters like the contract name, symbol, and contractURI.

Upon successful deployment, the contract address is logged to the console. This address represents the newly deployed NFT contract.

Congratulations! You have successfully deployed an ERC721Mintable NFT and are now are the owner of a token on the Sepolia testnet. Want proof? You can check this out Sepolia Etherscan