Are you looking for the only solution to get blockchain knowledge utilizing RPC strategies? Look no additional. On this information, we’ll introduce you to Moralis’ Extended RPC Methods, enabling you to question the identical enhanced, human-readable knowledge 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 displaying 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,
"method": "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 desired pockets. Right here’s an instance of what the output would possibly seem like:
{
//...
outcome: [
{
token_address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
name: 'Wrapped Ether',
symbol: 'WETH',
decimals: 18,
logo: '
thumbnail: '
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 via RPC strategies doesn’t must be extra difficult than this when utilizing Moralis. For a extra detailed tutorial, comply with together with this information or go to our Extended RPC Methods documentation web page.
Excited to start out utilizing our Extended RPC Methods? Join with Moralis at this time! Create a free account to entry our Extended RPC Methods, 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 characteristic standardized strategies, permitting builders to seamlessly learn and write blockchain knowledge. Nonetheless, customary RPC strategies are sometimes fairly restricted, not permitting for frequent queries like “What ERC-20 tokens are wallet X holding?” To get this data, it’s essential to make a number of requests and join the dots your self. Thankfully, now you can circumvent these challenges with Moralis’ Extended RPC Methods.
Our Extended RPC Methods can help you question decoded, human-readable blockchain knowledge seamlessly utilizing RPC-style strategies: fetch ERC-20 balances, token costs, metadata, and far more with single calls.
However how does this work? Should you’d prefer to be taught extra, be a part of us on this information as we lay all of it out for you. Let’s dive straight in!
What are RPC Methods?
RPC, brief for “Remote Procedure Call,” 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 pc. On the earth of crypto, RPC allows dapps and different Web3 platforms (shoppers) to work together with a blockchain community (server).
There are standardized protocols, one instance being JSON-RPC, that characteristic predefined strategies. These so-called RPC strategies can help you seamlessly carry out numerous operations, resembling studying blockchain knowledge, 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 worth.
General, RPC strategies simplify interplay with blockchain networks, facilitating the easy improvement of dapps and different Web3 initiatives.
Exploring the Limitations of Normal RPC Methods
Whereas RPC protocols simplify dapp improvement, they arrive with vital limitations that you should think about. Sometimes, customary RPC strategies solely present fundamental blockchain knowledge. As such, frequent RPC strategies are usually not designed to deal with queries resembling, “What ERC-20 tokens does wallet X hold?”
To acquire this sort 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 sources.
To handle these challenges, Moralis introduces Extended RPC Methods. However what precisely are these strategies, and the way do they profit builders?
Discover out within the subsequent part!
Introducing Moralis’ Extended RPC Methods
Our Extended RPC Methods considerably enhance our node answer, 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 knowledge, streamlining your Web3 developer expertise.
What do Moralis’ Enhanced RPC Methods embody?
eth_getTransactions: Get all native transactions for a given pockets.eth_getDecodedTransactions: Acquire an in depth transaction historical past for a particular 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: Acquire metadata for ERC-20 tokens.eth_getNFTBalances: Fetch all NFTs held by a pockets.eth_getNFTCollections: Acquire all NFT collections owned by a particular pockets deal with.
In abstract, Moralis’ Enhanced RPC Methods considerably prolong the capabilities of our nodes, giving you an identical enhanced knowledge you’d get utilizing our APIs, however via RPC-style requests!
3-Step Tutorial: Get All Blockchain Data via Extended RPC Methods
Now, with an outline of what Moralis’ Extended RPC Methods entail, we’ll present you how one can 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 node
- Write a script
- Execute the code
Step 1: Signal Up with Moralis & Create a Node
Should you haven’t already, click on the “Start for Free” button on the prime 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 one among your node URLs and hold 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 venture with the terminal command under:
npm init
As soon as initialized, set up the required dependencies utilizing the offered terminal command:
npm set up node-fetch --save npm set up moralis @moralisweb3/common-evm-utils
Subsequent, open bundle.json and add "type": "module" to the file:
After that, create an “index.js” file and insert the offered code:
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,
"method": "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 deal with parameter to suit your question:
That’s it for the code. All that continues to be now’s to execute the script.
Step 3: Execute the Code
To run the code, navigate to the foundation folder of the venture and run the next terminal command:
node index.js
In return, you’ll get the token balances of the desired deal with, enriched with logos, spam indicators, and far more. Right here’s what it’d seem like:
{
//...
outcome: [
{
token_address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
name: 'Wrapped Ether',
symbol: 'WETH',
decimals: 18,
logo: '
thumbnail: '
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’ Extended RPC Methods doesn’t must be more difficult than that!
Extended RPC Methods Use Circumstances
Our Extended RPC Methods 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 handbook knowledge aggregation.
- Transaction Histories: Entry transaction histories for any deal with via streamlined RPC calls.
- Token Costs: Acquire real-time token costs instantly from decentralized exchanges (DEXs) effortlessly.
With this complete knowledge, you may develop every little thing from cryptocurrency wallets to token explorers with minimal effort!
Past Extended RPC Methods – Exploring the Ins & Outs of Moralis’ Web3 APIs
Along with our enhanced RPC strategies, Moralis presents 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 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 take pleasure in a seamless developer expertise, enabling you to construct dapps sooner and extra effectively.
- Cross-Chain: We help full characteristic parity throughout over 30 blockchain networks, together with Ethereum, Polygon, Base, Optimism, and plenty of others. With Moralis, one supplier covers all of your knowledge wants.
- Safe: Moralis is SOC 2 Sort 2 licensed, guaranteeing 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 contains over ten distinct interfaces designed to satisfy various use instances. Whereas this information gained’t cowl all of them, we’ll spotlight three key examples:
- Pockets API
- Token API
- NFT API
Let’s begin with an in-depth take a look at our Pockets API!
Pockets API
The Pockets API presents a complete suite of options, unmatched flexibility, and distinctive scalability, making it the final word instrument for pockets builders. Use this interface to entry any pockets’s historical past, token balances, DeFi positions, and far more!
Supporting hundreds of thousands of addresses throughout all main chains, together with Ethereum, Polygon, Base, Optimism, and plenty of extra, the Pockets API lets you seamlessly combine pockets knowledge into your dapp, whatever the platform you’re constructing on.
To reveal the facility of the Pockets API, right here’s how simple 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(
'
choices
)
.then((response) => response.json())
.then((response) => console.log(response))
.catch((err) => console.error(err));
Operating the above script gives you with the whole transaction historical past of the desired 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 seem like:
{
//...
"result": [
{
"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": "
"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": [],
"summary": "Sent 50,000 USDT to Binance 14",
"possible_spam": false,
"category": "token send"
},
//...
]
}
Token API
Moralis’ Token API is your important instrument for fetching and integrating ERC-20 knowledge into your Web3 initiatives. With this premier interface, you may seamlessly retrieve token balances, costs, metadata, house owners, and far 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 reveal the facility of the Token API, we’ll present you how one can 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(' choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
By operating the offered script, you’ll obtain the token balances of the pockets, enriched with costs, worth modifications over time, and different metadata. Right here’s an instance of what the response will seem like:
{
//...
"result": [
{
"token_address": "0xae7ab96520de3a18e5e111b5eaab095312d7fe84",
"symbol": "stETH",
"name": "Liquid staked Ether 2.0",
"logo": "
"thumbnail": "
"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 may entry NFT balances, up-to-date metadata, costs, picture previews, and extra.
Moralis’ NFT API helps hundreds of thousands of NFT collections throughout all main blockchain networks, from well-known initiatives 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 instrument.
To reveal 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: 'utility/json',
'X-API-Key': 'YOUR_API_KEY'
},
};
fetch(' choices)
.then(response => response.json())
.then(response => console.log(response))
.catch(err => console.error(err));
Operating this script will return the metadata for the desired NFT, which can look one thing like this:
{
"amount": "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":" 001","attributes":["Smile","Mohawk"],"description":"Male"}",
"block_number": "16079985",
"block_number_minted": null,
"name": "CRYPTOPUNKS",
"symbol": "Ͼ",
"token_hash": "a99d02058e62e327e79aabd57e0b88a3",
"token_uri": "Invalid uri",
"minter_address": null,
"rarity_rank": 7247,
"rarity_percentage": 72.47,
"rarity_label": "Top 73%",
"verified_collection": true,
"possible_spam": false,
"collection_logo": "
"collection_banner_image": "
}
Go to the official Web3 API web page for extra data on our interfaces, together with the Blockchain API, Streams API, Market Data API, and others!
Abstract: Extended RPC Methods – Get All Blockchain Data via RPC Methods
RPC stands for “Remote Procedure Call,” and within the context of Web3, it refers to communication protocols that enable dapps to speak with blockchain networks. There are customary RPC protocols that characteristic RPC strategies. Nonetheless, conventional RPC strategies are sometimes restricted, offering solely fundamental on-chain knowledge. As an illustration, you may’t use typical RPC strategies to simply get the ERC-20 steadiness of a pockets. To get complete knowledge like this, you’d sometimes must make a number of requests and decode the knowledge manually. Thankfully, we provide a streamlined answer: Extended RPC Methods!
Our Extended RPC Methods ship the identical enhanced performance offered by our APIs however via RPC-style requests. With these, you may seamlessly question ERC-20 balances, token costs, metadata, and far more utilizing single calls. Listed here are a few of our prime strategies:
eth_getTransactions: Retrieve the transactions for a pockets deal with.eth_getDecodedTransactions: Acquire 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: 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 deal with.
All in all, our Extended RPC Methods enhance our node answer, providing you with entry to the identical enhanced performance that you’d get with our APIs however via RPC-style requests. In return, you may question decoded, human-readable knowledge straight out of your Moralis nodes!
Should you loved studying about our Extended RPC Methods, discover extra content material on our weblog. As an illustration, take a look at our guides on:
Prepared to make use of our Extended RPC Methods to get the identical enhanced knowledge our APIs present, however via RPC-style requests? Join with Moralis without cost and acquire immediate entry to our improvement instruments!
