Are you trying to find the only approach to get blockchain knowledge 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 knowledge our APIs present, however by way of RPC-style requests. This consists of 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: ‘software/json’,
‘content-type’: ‘software/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));
Working the code above will return the ERC-20 balances of the desired pockets. Right here’s an instance of what the output may appear to be:
 {
//…
outcome: [
{
token_address: ‘0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2’,
name: ‘Wrapped Ether’,
symbol: ‘WETH’,
decimals: 18,
logo: ‘https://logo.developers.moralis.com/0x1_0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2_a578c5277503e547a072ae32517254ca’,
thumbnail: ‘https://logo.developers.moralis.com/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 knowledge by way of RPC strategies doesn’t must be extra sophisticated than this when utilizing Moralis. For a extra detailed tutorial, observe together with this information or go to our Prolonged RPC Strategies documentation web page.
Excited to start out utilizing our Prolonged RPC Strategies? Join with Moralis at present! 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, and so they function standardized strategies, permitting builders to seamlessly learn and write blockchain knowledge. Nevertheless, customary 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. Thankfully, now you can circumvent these challenges with Moralis’ Prolonged RPC Strategies.
Our Prolonged RPC Strategies can help you question decoded, human-readable blockchain knowledge 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 be taught 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, quick for “Distant Process Name,” refers to communication protocols that permit one software program system to name and request a service from one other software program system on a unique laptop. On the planet of crypto, RPC permits dapps and different Web3 platforms (shoppers) to work together with a blockchain community (server).
There are standardized protocols, one instance being JSON-RPC, that function predefined strategies, akin to eth_getUncleByBlockHashAndIndex. These so-called RPC strategies can help you seamlessly carry out varied operations, akin to studying blockchain knowledge, sending transactions, and managing wallets.
Here’s a listing 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 stability of an account.
eth_gasPrice: Returns the present fuel worth.
Total, RPC strategies simplify interplay with blockchain networks, facilitating the easy improvement of dapps and different Web3 tasks.
Exploring the Limitations of Normal RPC Strategies
Whereas RPC protocols simplify dapp improvement, they arrive with important limitations that you should contemplate. Sometimes, customary RPC strategies solely present primary blockchain knowledge. As such, frequent RPC strategies usually are not designed to deal with queries akin to, “What ERC-20 tokens does pockets X maintain?”
To acquire this type of data utilizing typical RPC strategies, builders should make a number of requests and manually compile the information. This course of is cumbersome and time-consuming, demanding appreciable improvement effort and assets.
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 answer, delivering the identical enhanced functionalities present in Moralis’ APIs, however by way of RPC-style strategies. These superior strategies simplify the method of querying decoded, human-readable knowledge, streamlining your Web3 developer expertise.
What do Moralis’ Enhanced RPC Strategies embrace?
eth_getTransactions: Get all native transactions for a given pockets.
eth_getDecodedTransactions: Acquire an in depth transaction historical past for a selected pockets tackle.
eth_getTokenBalances: Retrieve ERC-20 token balances for a given pockets tackle.
eth_getTokenPrice: Fetch present costs for ERC-20 tokens.
eth_getTokenMetadata: Acquire metadata for ERC-20 tokens.
eth_getNFTBalances: Fetch all NFTs held by a pockets.
eth_getNFTCollections: Acquire all NFT collections owned by a selected pockets tackle.
In abstract, Moralis’ Enhanced RPC Strategies considerably lengthen the capabilities of our nodes, giving you a similar enhanced knowledge you’d get utilizing our APIs, however by way of RPC-style requests!
3-Step Tutorial: The right way to Get All Blockchain Knowledge by way of Prolonged RPC Strategies
Now, with an summary of what Moralis’ Prolonged RPC Strategies entail, we’ll present you the best way to use them in apply. Extra particularly, we’ll show how one can get the token stability for any given pockets in three easy steps:
Join with Moralis & create a node
Write a script
Execute 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:
Choose “Ethereum,” adopted by “Mainnet,” and hit “Create Node”:
Copy certainly one of your node URLs and preserve it for now, as you’ll want it within the subsequent step:
Step 2: Write a Script
Open your most well-liked IDE, arrange a brand new folder, and initialize a challenge with the terminal command beneath:Â
npm init
As soon as initialized, set up the required dependencies utilizing the supplied terminal command:
npm set up node-fetch –save
npm set up moralis @moralisweb3/common-evm-utils
Subsequent, open bundle.json and add “sort”: “module” to the file:Â
After that, create an “index.js” file and insert the supplied code:Â
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘POST’,
headers: {
settle for: ‘software/json’,
‘content-type’: ‘software/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));
From right here, you should make some minor configurations. First, add the node URL you copied throughout step one by changing YOUR_NODE_URL. Subsequent, configure the tackle parameter to suit your question:
That’s it for the code. All that is still now could be 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 desired tackle, enriched with logos, spam indicators, and way more. Right here’s what it would appear to be:
 {
//…
outcome: [
{
token_address: ‘0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2’,
name: ‘Wrapped Ether’,
symbol: ‘WETH’,
decimals: 18,
logo: ‘https://logo.developers.moralis.com/0x1_0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2_a578c5277503e547a072ae32517254ca’,
thumbnail: ‘https://logo.developers.moralis.com/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
},
//…
]
}
That’s it! Fetching knowledge utilizing Moralis’ Prolonged RPC Strategies doesn’t must be tougher 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 here are three frequent use instances for our enhanced RPC strategies, offering the identical knowledge as our highly effective APIs:
Token Balances: Retrieve token balances for any pockets with a single name, eliminating the necessity for guide knowledge aggregation.
Transaction Histories: Entry transaction histories for any tackle by way of streamlined RPC calls.
Token Costs: Acquire real-time token costs immediately from decentralized exchanges (DEXs) effortlessly.
With this complete knowledge, you’ll be able to develop every little thing 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 gives a various suite of use case-specific APIs, together with the Pockets API, Token API, Streams API, and lots of extra. These premier interfaces allow you to effortlessly construct every little thing from Web3 wallets to token explorers.
Why select Moralis’ APIs?
Complete: Moralis’ Web3 APIs are outcome-focused, offering extra knowledge with fewer calls. This lets you get pleasure from a seamless developer expertise, enabling you to construct dapps quicker and extra effectively.
Cross-Chain: We help full function parity throughout over 30 blockchain networks, together with Ethereum, Polygon, Base, Optimism, and lots of others. With Moralis, one supplier covers all of your knowledge wants.
Safe: Moralis is SOC 2 Kind 2 licensed, making certain enterprise-grade knowledge safety to your functions.
Let’s dive deeper into our API suite to discover the capabilities of our premier interfaces and the way they’ll empower your improvement course of!
Moralis’ Web3 API Suite
Our complete suite of Web3 APIs consists of over ten distinct interfaces designed to satisfy various use instances. Whereas this information received’t cowl all of them, we’ll spotlight three key examples:
Pockets API
Token API
NFT API
Let’s begin with an in-depth have a look at our Pockets API!
Pockets API
The Pockets API gives 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 tens of millions of addresses throughout all main chains, together with Ethereum, Polygon, Base, Optimism, and lots of extra, the Pockets API lets you seamlessly combine pockets knowledge into your dapp, whatever the platform you’re constructing on.
To show 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: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(
‘https://deep-index.builders.moralis.com/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));
Working the above script gives you with the entire transaction historical past of the desired pockets, enriched with human-readable class tags, summaries, tackle labels, and extra for every occasion. Right here’s an instance of what it would appear to be:
{
//…
“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.developers.moralis.com/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 knowledge into your Web3 tasks. With this premier interface, you’ll be able to 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 little thing in between. This complete protection lets you effortlessly construct cross-chain token explorers, portfolio trackers, and extra.
To show the facility of the Token API, we’ll present you the best way to fetch token balances with costs for any pockets:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(‘https://deep-index.builders.moralis.com/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, worth adjustments over time, and different metadata. Right here’s an instance of what the response will appear to be:
{
//…
“outcome”: [
{
“token_address”: “0xae7ab96520de3a18e5e111b5eaab095312d7fe84”,
“symbol”: “stETH”,
“name”: “Liquid staked Ether 2.0”,
“logo”: “https://logo.developers.moralis.com/0x1_0xae7ab96520de3a18e5e111b5eaab095312d7fe84_cd0f5053ccb543e08f65554bf642d751”,
“thumbnail”: “https://logo.developers.moralis.com/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 gives complete NFT knowledge at your fingertips. With only a few traces of code, you’ll be able to entry NFT balances, up-to-date metadata, costs, picture previews, and extra.
Moralis’ NFT API helps tens of millions of NFT collections throughout all main blockchain networks, from well-known tasks like CryptoPunks to newly minted tokens. Whether or not you’re creating NFT marketplaces, Web3 video games, or related platforms, this API is a vital software.
To show the convenience of use, right here’s a script that fetches NFT metadata effortlessly:
import fetch from ‘node-fetch’;
const choices = {
methodology: ‘GET’,
headers: {
settle for: ‘software/json’,
‘X-API-Key’: ‘YOUR_API_KEY’
},
};
fetch(‘https://deep-index.builders.moralis.com/api/v2.2/nft/0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB/1?chain=eth’, choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Working this script will return the metadata for the desired 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”: “High 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 Knowledge API, and others!
Abstract: Prolonged RPC Strategies – Get All Blockchain Knowledge by way of RPC Strategies
RPC stands for “Distant Process Name,” and within the context of Web3, it refers to communication protocols that permit dapps to speak with blockchain networks. There are customary RPC protocols that function RPC strategies. Nevertheless, conventional RPC strategies are sometimes restricted, offering solely primary on-chain knowledge. As an illustration, you’ll be able to’t use typical RPC strategies to simply get the ERC-20 stability of a pockets. To get complete knowledge like this, you’d usually have to make a number of requests and decode the data manually. Thankfully, we provide a streamlined answer: Prolonged RPC Strategies!
Our Prolonged RPC Strategies ship the identical enhanced performance supplied by our APIs however by way of RPC-style requests. With these, you’ll be able to seamlessly question ERC-20 balances, token costs, metadata, and way more utilizing single calls. Listed here are a few of our high strategies:
eth_getTransactions: Retrieve the transactions for a pockets tackle.
eth_getDecodedTransactions: Acquire detailed transaction historical past for a pockets tackle.
eth_getTokenBalances: Retrieve ERC-20 token balances for a pockets tackle.
eth_getTokenPrice: Fetch present costs for ERC-20 tokens.
eth_getTokenMetadata: Acquire metadata for ERC-20 tokens by their addresses.
eth_getNFTBalances: Retrieve NFTs held by a pockets.
eth_getNFTCollections: Acquire NFT collections owned by a pockets tackle.
All in all, our Prolonged RPC Strategies enhance our node answer, providing you with entry to the identical enhanced performance that you’d get with our APIs however by way of RPC-style requests. In return, you’ll be able to question decoded, human-readable knowledge straight out of your Moralis nodes!
For those who loved studying about our Prolonged RPC Strategies, discover extra content material on our weblog. As an illustration, take a look at our guides on:
Prepared to make use of our Prolonged RPC Strategies to get the identical enhanced knowledge our APIs present, however by way of RPC-style requests? Join with Moralis at no cost and acquire instantaneous entry to our improvement instruments!
