Extended RPC Methods - Get All Blockchain Data via RPC Methods - Moralis Web3

Are you looking for the best solution to get blockchain information utilizing RPC strategies? Look no additional. On this information, we’ll introduce you to Moralis’ Prolonged RPC Strategies, enabling you to question the identical enhanced, human-readable information our APIs present, however via RPC-style requests. This contains ERC-20 balances, transaction histories, token metadata, and extra. Prepared to leap into the code? Right here’s a script exhibiting our eth_getTokenBalances methodology in motion:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘POST’,
headers: {
settle for: ‘utility/json’,
‘content-type’: ‘utility/json’
},
physique: JSON.stringify({
“jsonrpc”: “2.0”,
“id”: 1,
“methodology”: “eth_getTokenBalances”,
“params”: [
{
“address”: “0xcB1C1FdE09f811B294172696404e88E658659905”,
}
]
})
};

fetch(‘YOUR_NODE_URL’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

Operating the code above will return the ERC-20 balances of the required pockets. Right here’s an instance of what the output would possibly appear like:

{
//…
outcome: [
{
token_address: ‘0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2’,
name: ‘Wrapped Ether’,
symbol: ‘WETH’,
decimals: 18,
logo: ‘https://logo.moralis.io/0x1_0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2_a578c5277503e547a072ae32517254ca’,
thumbnail: ‘https://logo.moralis.io/0x1_0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2_a578c5277503e547a072ae32517254ca’,
balance: ‘10000000000000000’,
possible_spam: false,
verified_contract: true,
total_supply: ‘2746607222348759943423350’,
total_supply_formatted: ‘2746607.22234875994342335’,
percentage_relative_to_total_supply: 3.64085549569e-7
},
//…
]
}

Fetching blockchain information through RPC strategies doesn’t should be extra difficult than this when utilizing Moralis. For a extra detailed tutorial, comply with together with this information or go to our Prolonged RPC Strategies documentation web page.

Excited to begin utilizing our Prolonged RPC Strategies? Join with Moralis as we speak! Create a free account to entry our Prolonged RPC Strategies, RPC Nodes, and premier APIs instantly.

Overview

Within the context of Web3, RPC refers to communication protocols that streamline the interplay between decentralized functions (dapps) and blockchain networks. There are a number of RPC protocols, they usually function standardized strategies, permitting builders to seamlessly learn and write blockchain information. Nonetheless, commonplace RPC strategies are usually fairly restricted, not permitting for frequent queries like “What ERC-20 tokens are pockets X holding?” To get this data, you could make a number of requests and join the dots your self. Happily, now you can circumvent these challenges with Moralis’ Prolonged RPC Strategies.

Our Prolonged RPC Strategies permit you to question decoded, human-readable blockchain information seamlessly utilizing RPC-style strategies: fetch ERC-20 balances, token costs, metadata, and way more with single calls.

However how does this work? For those who’d prefer to study extra, be part of us on this information as we lay all of it out for you. Let’s dive straight in!

What are RPC Strategies?

RPC, brief for “Distant Process Name,” refers to communication protocols that enable one software program system to name and request a service from one other software program system on a distinct laptop. On the earth of crypto, RPC allows dapps and different Web3 platforms (purchasers) to work together with a blockchain community (server).

There are standardized protocols, one instance being JSON-RPC, that function predefined strategies. These so-called RPC strategies permit you to seamlessly carry out varied operations, equivalent to studying blockchain information, sending transactions, and managing wallets.

Here’s a record of frequent RPC strategies for Ethereum:

eth_blockNumber: Returns the variety of the newest block.eth_call: Executes a brand new message name.eth_chainId: Returns the present chain ID.eth_getBalance: Returns the steadiness of an account.eth_gasPrice: Returns the present gasoline value.

General, RPC strategies simplify interplay with blockchain networks, facilitating the easy growth of dapps and different Web3 tasks.

Exploring the Limitations of Normal RPC Strategies

Whereas RPC protocols simplify dapp growth, they arrive with important limitations that you must contemplate. Usually, commonplace RPC strategies solely present primary blockchain information. As such, frequent RPC strategies will not be designed to deal with queries equivalent to, “What ERC-20 tokens does pockets X maintain?”

To acquire this type of data utilizing standard RPC strategies, builders should make a number of requests and manually compile the info. This course of is cumbersome and time-consuming, demanding appreciable growth effort and sources.

To deal with these challenges, Moralis introduces Prolonged RPC Strategies. However what precisely are these strategies, and the way do they profit builders?

Discover out within the subsequent part!

Introducing Moralis’ Prolonged RPC Strategies

Our Prolonged RPC Strategies considerably enhance our node resolution, delivering the identical enhanced functionalities present in Moralis’ APIs, however via RPC-style strategies. These superior strategies simplify the method of querying decoded, human-readable information, streamlining your Web3 developer expertise.

What do Moralis’ Enhanced RPC Strategies embrace?

eth_getTransactions: Get all native transactions for a given pockets.eth_getDecodedTransactions: Get hold of an in depth transaction historical past for a selected pockets deal with.eth_getTokenBalances: Retrieve ERC-20 token balances for a given pockets deal with.eth_getTokenPrice: Fetch present costs for ERC-20 tokens.eth_getTokenMetadata: Get hold of metadata for ERC-20 tokens.eth_getNFTBalances: Fetch all NFTs held by a pockets.eth_getNFTCollections: Get hold of all NFT collections owned by a selected pockets deal with.

In abstract, Moralis’ Enhanced RPC Strategies considerably prolong the capabilities of our nodes, giving you an identical enhanced information you’d get utilizing our APIs, however through RPC-style requests!

3-Step Tutorial: How one can Get All Blockchain Information through Prolonged RPC Strategies

Now, with an outline of what Moralis’ Prolonged RPC Strategies entail, we’ll present you learn how to use them in follow. Extra particularly, we’ll reveal how one can get the token steadiness for any given pockets in three easy steps:

Join with Moralis & create a nodeWrite a scriptExecute the code

Step 1: Signal Up with Moralis & Create a Node

For those who haven’t already, click on the “Begin for Free” button on the high proper to enroll with Moralis:

When you log in, go to the “Nodes” tab and click on the “+ Create Node” button:

Red arrows pointing at "Nodes" tab and "+ Create Node" button.

Choose “Ethereum,” adopted by “Mainnet,” and hit “Create Node”:

"Ethereum" and "Mainnet" selected when creating node.

Copy considered one of your node URLs and hold it for now, as you’ll want it within the subsequent step:

Red arrows pointing at copy button for node URLs.

Step 2: Write a Script

Open your most well-liked IDE, arrange a brand new folder, and initialize a challenge with the terminal command under:

npm init

As soon as initialized, set up the mandatory dependencies utilizing the supplied terminal command:

npm set up node-fetch –save
npm set up moralis @moralisweb3/common-evm-utils

Subsequent, open package deal.json and add “kind”: “module” to the file:

Type: module highlighted in code editor.

After that, create an “index.js” file and insert the supplied code:

import fetch from ‘node-fetch’;

fetch(‘YOUR_NODE_URL’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

From right here, you must make some minor configurations. First, add the node URL you copied throughout step one by changing YOUR_NODE_URL. Subsequent, configure the deal with parameter to suit your question:

That’s it for the code. All that is still now’s to execute the script.

Step 3: Execute the Code

To run the code, navigate to the foundation folder of the challenge and run the next terminal command:

node index.js

In return, you’ll get the token balances of the required deal with, enriched with logos, spam indicators, and way more. Right here’s what it’d appear like:

That’s it! Fetching information utilizing Moralis’ Prolonged RPC Strategies doesn’t should be more difficult than that!

Prolonged RPC Strategies Use Instances

Our Prolonged RPC Strategies considerably enhance the Web3 developer expertise, enabling you to construct a variety of dapps effortlessly. Listed below are three frequent use instances for our enhanced RPC strategies, offering the identical information as our highly effective APIs:

Token Balances: Retrieve token balances for any pockets with a single name, eliminating the necessity for guide information aggregation. Transaction Histories: Entry transaction histories for any deal with via streamlined RPC calls. Token Costs: Get hold of real-time token costs instantly from decentralized exchanges (DEXs) effortlessly.

With this complete information, you may develop every part from cryptocurrency wallets to token explorers with minimal effort!

Past Prolonged RPC Strategies – Exploring the Ins & Outs of Moralis’ Web3 APIs

Along with our enhanced RPC strategies, Moralis provides a various suite of use case-specific APIs, together with the Pockets API, Token API, Streams API, and plenty of extra. These premier interfaces allow you to effortlessly construct every part from Web3 wallets to token explorers.

Why select Moralis’ APIs?

Complete: Moralis’ Web3 APIs are outcome-focused, offering extra information with fewer calls. This lets you get pleasure from a seamless developer expertise, enabling you to construct dapps sooner and extra effectively. Cross-Chain: We help full function parity throughout over 30 blockchain networks, together with Ethereum, Polygon, Base, Optimism, and plenty of others. With Moralis, one supplier covers all of your information wants. Safe: Moralis is SOC 2 Sort 2 licensed, making certain enterprise-grade information safety on your functions.

Let’s dive deeper into our API suite to discover the capabilities of our premier interfaces and the way they will empower your growth course of!

Moralis’ Web3 API Suite

Our complete suite of Web3 APIs contains over ten distinct interfaces designed to fulfill various use instances. Whereas this information received’t cowl all of them, we’ll spotlight three key examples:

Pockets APIToken APINFT API

Let’s begin with an in-depth have a look at our Pockets API!

Pockets API

The Pockets API provides a complete suite of options, unmatched flexibility, and distinctive scalability, making it the final word software for pockets builders. Use this interface to entry any pockets’s historical past, token balances, DeFi positions, and way more!

Supporting thousands and thousands of addresses throughout all main chains, together with Ethereum, Polygon, Base, Optimism, and plenty of extra, the Pockets API permits you to seamlessly combine pockets information into your dapp, whatever the platform you’re constructing on.

To reveal the facility of the Pockets API, right here’s how straightforward it’s to fetch a pockets’s transaction historical past:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(
‘https://deep-index.moralis.io/api/v2.2/wallets/0xda74Ac6b69Ff4f1B6796cdDf61fBDd4A5f68525f/historical past?chain=eth&order=DESC’,
choices
)
.then((response) => response.json())
.then((response) => console.log(response))
.catch((err) => console.error(err));

Operating the above script supplies you with the whole transaction historical past of the required pockets, enriched with human-readable class tags, summaries, deal with labels, and extra for every occasion. Right here’s an instance of what it’d appear like:

{
//…
“outcome”: [
{
“hash”: “0xc565260238f59fc3f35b74f3011375c7d637db9b075f77d342c30d19f946272e”,
“nonce”: “14”,
“transaction_index”: “75”,
“from_address”: “0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f”,
“from_address_label”: null,
“to_address”: “0xdac17f958d2ee523a2206206994597c13d831ec7”,
“to_address_label”: “Tether USD (USDT)”,
“value”: “0”,
“gas”: “55331”,
“gas_price”: “13623172301”,
“receipt_cumulative_gas_used”: “13917979”,
“receipt_gas_used”: “41309”,
“receipt_status”: “1”,
“block_timestamp”: “2024-05-14T14:00:23.000Z”,
“block_number”: “19868695”,
“block_hash”: “0x660274d577cd20b0b82c1bff5f3c5641ba6027544e005f9256d5add9c7447920”,
“transaction_fee”: “0.000562759624582009”,
“nft_transfers”: [],
“erc20_transfers”: [
{
“token_name”: “Tether USD”,
“token_symbol”: “USDT”,
“token_logo”: “https://logo.moralis.io/0x1_0xdac17f958d2ee523a2206206994597c13d831ec7_0b0d126af6c744c185e112a2c8dc1495”,
“token_decimals”: “6”,
“from_address”: “0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f”,
“from_address_label”: null,
“to_address”: “0x28c6c06298d514db089934071355e5743bf21d60”,
“to_address_label”: “Binance 14”,
“address”: “0xdac17f958d2ee523a2206206994597c13d831ec7”,
“log_index”: 338,
“value”: “50000000000”,
“possible_spam”: false,
“verified_contract”: true,
“direction”: “send”,
“value_formatted”: “50000”
}
],
“method_label”: null,
“native_transfers”: [],
“abstract”: “Despatched 50,000 USDT to Binance 14”,
“possible_spam”: false,
“class”: “token ship”
},
//…
]
}

Token API

Moralis’ Token API is your important software for fetching and integrating ERC-20 information into your Web3 tasks. With this premier interface, you may seamlessly retrieve token balances, costs, metadata, homeowners, and way more.

The Token API covers each single token throughout all main chains, together with stablecoins like USDT, meme cash like Shiba Inu, LP tokens, and every part in between. This complete protection permits you to effortlessly construct cross-chain token explorers, portfolio trackers, and extra.

To reveal the facility of the Token API, we’ll present you learn how to fetch token balances with costs for any pockets:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(‘https://deep-index.moralis.io/api/v2.2/wallets/0xcB1C1FdE09f811B294172696404e88E658659905/tokens?chain=eth’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

By working the supplied script, you’ll obtain the token balances of the pockets, enriched with costs, value adjustments over time, and different metadata. Right here’s an instance of what the response will appear like:

{
//…
“outcome”: [
{
“token_address”: “0xae7ab96520de3a18e5e111b5eaab095312d7fe84”,
“symbol”: “stETH”,
“name”: “Liquid staked Ether 2.0”,
“logo”: “https://logo.moralis.io/0x1_0xae7ab96520de3a18e5e111b5eaab095312d7fe84_cd0f5053ccb543e08f65554bf642d751”,
“thumbnail”: “https://logo.moralis.io/0x1_0xae7ab96520de3a18e5e111b5eaab095312d7fe84_cd0f5053ccb543e08f65554bf642d751”,
“decimals”: 18,
“balance”: “61135846911533523”,
“possible_spam”: false,
“verified_contract”: true,
“total_supply”: “9788873903061556217474312”,
“total_supply_formatted”: “9788873.903061556217474312”,
“percentage_relative_to_total_supply”: 6.2454422763e-7,
“balance_formatted”: “0.061135846911533523”,
“usd_price”: 2731.4812583950234,
“usd_price_24hr_percent_change”: 2.9851365470017,
“usd_price_24hr_usd_change”: 79.1749645169798,
“usd_value”: 166.99142005496108,
“usd_value_24hr_usd_change”: 4.840428509936174,
“native_token”: false,
“portfolio_percentage”: 44.16600478357348
},
//…
]
}

NFT API

The NFT API supplies complete NFT information at your fingertips. With just some traces of code, you may entry NFT balances, up-to-date metadata, costs, picture previews, and extra.

Moralis’ NFT API helps thousands and thousands of NFT collections throughout all main blockchain networks, from well-known tasks like CryptoPunks to newly minted tokens. Whether or not you’re growing NFT marketplaces, Web3 video games, or comparable platforms, this API is a vital software.

To reveal the benefit of use, right here’s a script that fetches NFT metadata effortlessly:

import fetch from ‘node-fetch’;

const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘utility/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};

fetch(‘https://deep-index.moralis.io/api/v2.2/nft/0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB/1?chain=eth’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));

Operating this script will return the metadata for the required NFT, which can look one thing like this:

{
“quantity”: “1”,
“token_id”: “1”,
“token_address”: “0xb47e3cd837ddf8e4c57f05d70ab865de6e193bbb”,
“contract_type”: “CRYPTOPUNKS”,
“owner_of”: “0xffa914c83d851b9fe372e4ba6a6e131373aa16ab”,
“last_metadata_sync”: “2024-08-10T14:39:45.042Z”,
“last_token_uri_sync”: “2024-08-10T14:39:44.622Z”,
“metadata”: “{“picture”:”https://www.larvalabs.com/cryptopunks/cryptopunk001.png”,”title”:”CryptoPunk 001″,”attributes”:[“Smile”,”Mohawk”],”description”:”Male”}”,
“block_number”: “16079985”,
“block_number_minted”: null,
“title”: “CRYPTOPUNKS”,
“image”: “Ͼ”,
“token_hash”: “a99d02058e62e327e79aabd57e0b88a3”,
“token_uri”: “Invalid uri”,
“minter_address”: null,
“rarity_rank”: 7247,
“rarity_percentage”: 72.47,
“rarity_label”: “Prime 73%”,
“verified_collection”: true,
“possible_spam”: false,
“collection_logo”: “https://i.seadn.io/gae/BdxvLseXcfl57BiuQcQYdJ64v-aI8din7WPk0Pgo3qQFhAUH-B6i-dCqqc_mCkRIzULmwzwecnohLhrcH8A9mpWIZqA7ygc52Sr81hE?w=500&auto=format”,
“collection_banner_image”: “https://i.seadn.io/gae/48oVuDyfe_xhs24BC2TTVcaYCX7rrU5mpuQLyTgRDbKHj2PtzKZsQ5qC3xTH4ar34wwAXxEKH8uUDPAGffbg7boeGYqX6op5vBDcbA?w=500&auto=format”
}

Go to the official Web3 API web page for extra data on our interfaces, together with the Blockchain API, Streams API, Market Information API, and others!

Abstract: Prolonged RPC Strategies – Get All Blockchain Information through RPC Strategies

RPC stands for “Distant Process Name,” and within the context of Web3, it refers to communication protocols that enable dapps to speak with blockchain networks. There are commonplace RPC protocols that function RPC strategies. Nonetheless, conventional RPC strategies are sometimes restricted, offering solely primary on-chain information. For example, you may’t use standard RPC strategies to simply get the ERC-20 steadiness of a pockets. To get complete information like this, you’d usually have to make a number of requests and decode the knowledge manually. Happily, we provide a streamlined resolution: Prolonged RPC Strategies!

Our Prolonged RPC Strategies ship the identical enhanced performance supplied by our APIs however through RPC-style requests. With these, you may seamlessly question ERC-20 balances, token costs, metadata, and way more utilizing single calls. Listed below are a few of our high strategies:

eth_getTransactions: Retrieve the transactions for a pockets deal with.eth_getDecodedTransactions: Get hold of detailed transaction historical past for a pockets deal with.eth_getTokenBalances: Retrieve ERC-20 token balances for a pockets deal with.eth_getTokenPrice: Fetch present costs for ERC-20 tokens.eth_getTokenMetadata: Get hold of metadata for ERC-20 tokens by their addresses.eth_getNFTBalances: Retrieve NFTs held by a pockets.eth_getNFTCollections: Get hold of NFT collections owned by a pockets deal with.

All in all, our Prolonged RPC Strategies enhance our node resolution, supplying you with entry to the identical enhanced performance that you’d get with our APIs however through RPC-style requests. In return, you may question decoded, human-readable information straight out of your Moralis nodes!

For those who loved studying about our Prolonged RPC Strategies, discover extra content material on our weblog. For example, take a look at our guides on:

Prepared to make use of our Prolonged RPC Strategies to get the identical enhanced information our APIs present, however through RPC-style requests? Join with Moralis without spending a dime and acquire instantaneous entry to our growth instruments!

Source link