Full Tutorial: How to Get Wallet Transactions Using RPC Nodes
Are you in search of a straightforward manner to get pockets transactions utilizing RPC nodes? In that case, you’re in the correct place. In in the present day’s tutorial, we’ll discover Moralis’ Prolonged RPC Strategies and our eth_getTransactions
endpoint, which permits you to fetch any pockets’s native transaction historical past with only one name. Keen to be taught the way it works? Try the strategy in motion right here:
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_getTransactions", "params": [ { "address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "limit": 100, } ] }) }; fetch('YOUR_NODE_URL', choices) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));
By working the script above, you’ll obtain the native transaction historical past of the desired pockets, enriched with timestamps, gasoline costs, tackle labels, and extra. Right here’s a pattern response:
{ //... end result: [ { hash: '0xd89b02f289a08ae7b2feead06031fec20777bad8b73fc8d853f9040bc423a6c7', nonce: '0', transaction_index: '142', from_address: '0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f', from_address_label: '', to_address: '0xdac17f958d2ee523a2206206994597c13d831ec7', to_address_label: 'Tether USD (USDT)', value: '0', gas: '207128', gas_price: '17020913648', input: '0xa9059cbb00000000000000000000000028c6c06298d514db089934071355e5743bf21d6000000000000000000000000000000000000000000000000000000017a1df1700', receipt_cumulative_gas_used: '8270587', receipt_gas_used: '41309', receipt_contract_address: null, receipt_root: null, receipt_status: '1', block_timestamp: '2023-01-22T15:00:11.000Z', block_number: '16463098', block_hash: '0x2439330d0a282f9a6464b0aceb9f766ac4d7b050c048b4a1322b48544c61e01d', transaction_fee: '0.000703116921885232' }, //... ] } }
That’s it! It’s simple to retrieve pockets transactions utilizing RPC nodes when working with Moralis. Nonetheless, for a extra detailed tutorial, be a part of us on this article or try the Moralis YouTube video beneath:
Need to get pockets transactions utilizing RPC nodes your self? Join free with Moralis to instantly entry all our Prolonged RPC Strategies!
Overview
In the event you’re wanting to construct decentralized functions (dapps), whether or not it’s a cryptocurrency pockets, portfolio tracker, tax platform, or comparable tasks, you’ll probably want entry to your customers’ native transaction historical past. Nonetheless, when you’re planning on getting this data utilizing RPC nodes, it’s simpler mentioned than completed, because it requires a number of requests and intensive guide information aggregation. Happily, there’s now a greater manner: Moralis’ Prolonged RPC Strategies.
With our Prolonged RPC Strategies, you’ll be able to question the identical decoded information that our APIs present, however via RPC-style requests. A single name permits you to retrieve a pockets’s native transaction historical past, token costs, token balances, and way more.
However how does this work? In the event you’d like to be taught extra about our Prolonged RPC Strategies, be a part of us on this tutorial. Let’s dive straight in!
Introducing Moralis’ Subsequent-Era RPC Nodes – The Best Manner to Get Wallet Transactions
Moralis is the business’s main supplier of next-generation RPC nodes. With our intuitive person interface, you’ll be able to entry nodes for all main chains with only a click on. As such, it doesn’t matter what community you’re constructing on, we’ve acquired you lined.
However what makes our nodes distinctive?
- Velocity: Our RPC nodes set the benchmark for velocity, with response instances as little as 70 ms.
- Reliability: With 99.9% uptime, you’ll be able to belief our node infrastructure.
- Prolonged RPC Strategies: Moralis’ Prolonged RPC Strategies improve our node providing, permitting you to question decoded, human-readable information by way of RPC-style requests.
Now, let’s dive a bit deeper into our Prolonged RPC Strategies, which allow you to seamlessly get pockets transactions utilizing RPC nodes!
Prolonged RPC Strategies
Moralis’ Prolonged RPC Strategies make fetching decoded, human-readable information with RPC nodes a breeze. With only one name, you’ll be able to effortlessly get pockets transactions, NFTs, token costs, metadata, and way more. As such, when utilizing Moralis and our Prolonged RPC Strategies, you’ll be able to considerably streamline your developer expertise.
What information are you able to fetch with our Prolonged RPC Strategies?
eth_getTransactions
: Get the native transactions of a pockets.eth_getDecodedTransactions
: Question the total transaction historical past of a pockets.eth_getTokenBalances
: Retrieve the ERC-20 balances of a pockets.eth_getTokenMetadata
: Get the metadata of any ERC-20 token.eth_getTokenPrice
: Entry the value of any ERC-20 token.eth_getNFTBalances
: Get the NFT balances of any pockets.eth_getNFTCollections
: Fetch the NFT collections held by a pockets.
In abstract, with our Prolonged RPC Strategies, you’ll be able to seamlessly fetch the identical decoded, human-readable information our APIs present, however via RPC-style requests.
eth_getTransactions
– Get Wallet Transactions Using RPC Nodes with One Request
With the eth_getTransactions
methodology, now you can seamlessly get any pockets’s native transaction historical past with only one single RPC request. Every transaction can be totally enriched with further information, together with time stamps, gasoline costs, tackle labels, and way more. As such, when utilizing the eth_getTransactions
endpoint, you get decoded information out of the field with only one name.
However how does this work? And what does an precise response seem like? In the event you’re in search of the solutions to these questions, be a part of us within the subsequent part, the place we present you precisely how to get pockets transactions utilizing RPC nodes in three easy steps.
Tutorial: How to Get Wallet Transactions Using RPC Nodes
With our Prolonged RPC Strategies and the eth_getTransactions
endpoint, you will get pockets transactions utilizing RPC nodes in three easy steps:
- Join with Moralis & get a node URL.
- Write a script calling
eth_getTransactions
. - Run the code.
However earlier than we are able to dive into the tutorial, you want to cope with just a few stipulations.
Stipulations
Ensure you have the next prepared earlier than persevering with:
Step 1: Signal Up with Moralis & Get a Node URL
Click on the ”Begin for Free” button on the prime proper and enroll with Moralis:
Log in, navigate to the ”Nodes” tab, and click on ”+ Create Node”:
Select ”Ethereum,” then ”Mainnet,” and click on ”Create Node”:
Copy and save one in all your node URLs, as you’ll want it within the subsequent step:
Step 2: Write a Script Calling eth_getTransactions
Launch your IDE, arrange a folder, open a brand new terminal, and initialize a undertaking with this command:
npm init
Set up the required dependencies with the next command:
npm set up node-fetch --save npm set up moralis @moralisweb3/common-evm-utils
Open your ”package deal.json” file and add ”kind”: ”module”
to the checklist:
Create an ”index.js” file and add the code beneath:
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_getTransactions", "params": [ { "address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "limit": 100, } ] }) }; fetch('YOUR_NODE_URL', choices) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));
Subsequent, you want to alter the code barely. Change YOUR_NODE_URL
with the node URL you copied throughout step one. Additionally, configure the tackle
parameter in order that it matches your request:
Step 3: Run the Code
Open a brand new terminal and run this command in your undertaking’s root folder:
node index.js
In return, you’ll get a listing of the pockets’s previous native transactions, enriched with timestamps, gasoline costs, tackle labels, and way more information for every occasion. Right here’s a pattern response:
{ //... end result: [ { hash: '0xd89b02f289a08ae7b2feead06031fec20777bad8b73fc8d853f9040bc423a6c7', nonce: '0', transaction_index: '142', from_address: '0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f', from_address_label: '', to_address: '0xdac17f958d2ee523a2206206994597c13d831ec7', to_address_label: 'Tether USD (USDT)', value: '0', gas: '207128', gas_price: '17020913648', input: '0xa9059cbb00000000000000000000000028c6c06298d514db089934071355e5743bf21d6000000000000000000000000000000000000000000000000000000017a1df1700', receipt_cumulative_gas_used: '8270587', receipt_gas_used: '41309', receipt_contract_address: null, receipt_root: null, receipt_status: '1', block_timestamp: '2023-01-22T15:00:11.000Z', block_number: '16463098', block_hash: '0x2439330d0a282f9a6464b0aceb9f766ac4d7b050c048b4a1322b48544c61e01d', transaction_fee: '0.000703116921885232' }, //... ] } }
That’s it; it’s simple to get pockets transactions utilizing RPC nodes when working with Moralis!
To be taught extra about this, try the official eth_getTransactions
documentation web page.
Use Instances for Wallet Transaction Knowledge
Now that you understand how to seamlessly get pockets transactions utilizing RPC nodes, let’s discover some distinguished use circumstances for this information. Listed here are three key examples:
- Cryptocurrency Wallets: Wallets require entry to transactions to show previous transfers, offering customers with a transparent overview of their historic exercise.
- Portfolio Trackers: Portfolio trackers should entry previous transfers to precisely monitor the efficiency of customers’ belongings.
- Tax Platforms: Tax platforms want a complete overview of customers’ previous buying and selling actions to generate correct tax reviews.
Be aware that these are only a few examples – pockets transaction information is essential for many dapps!
Past How to Get Wallet Transactions Using RPC Nodes – Diving Deeper Into Moralis’ Prolonged RPC Strategies
Now that you understand how to get pockets transactions utilizing RPC nodes, we’ll dive a bit deeper into our different Prolonged RPC Strategies. Extra particularly, we’ll discover the next three:
eth_getTokenBalances
eth_getDecodedTransactions
eth_getTokenPrice
So, let’s kick issues off with eth_getTokenBalances
!
eth_getTokenBalances
With our eth_getTokenBalances
methodology, you’ll be able to seamlessly get ERC-20 token balances utilizing RPC nodes. As an alternative of getting to make a number of RPC requests and stitching collectively information by yourself, you solely want a single name. Right here’s the strategy 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));
In response to calling the eth_getTokenBalances
methodology, you’ll obtain the ERC-20 token balances of the desired pockets. What’s extra, all tokens are enriched with logos, decimals, thumbnails, spam indicators, and way more. Right here’s a pattern response:
{ //... end result: [ { 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 }, //... ] }
eth_getDecodedTransactions
With the eth_getDecodedTransactions
methodology, you’ll be able to effortlessly get decoded pockets historical past utilizing an RPC node. No want to make a number of requests, combination information your self, or decode data. When utilizing Moralis, you get all the info you want with only one name. Right here’s an instance of how to name the eth_getDecodedTransactions
endpoint:
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_getDecodedTransactions", "params": [ { "address": "0xda74Ac6b69Ff4f1B6796cdDf61fBDd4A5f68525f", } ] }) }; fetch('YOUR_NODE_URL', choices) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));
In response to calling eth_getDecodedTransactions
, you’ll obtain the desired pockets’s full historical past, enriched with automated class tags, occasion summaries, tackle labels, and extra. Right here’s an instance of what the response may seem like:
{ //... "result": [ { "block_hash": "0x660274d577cd20b0b82c1bff5f3c5641ba6027544e005f9256d5add9c7447920", "block_number": "19868695", "block_timestamp": "2024-05-14T14:00:23.000Z", "from_address": "0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f", "from_address_label": null, "from_address_entity": null, "from_address_entity_logo": null, "to_address": "0xdac17f958d2ee523a2206206994597c13d831ec7", "to_address_label": "Tether USD (USDT)", "to_address_entity": null, "to_address_entity_logo": null, "gas": "55331", "gas_price": "13623172301", "hash": "0xc565260238f59fc3f35b74f3011375c7d637db9b075f77d342c30d19f946272e", "nonce": "14", "receipt_cumulative_gas_used": "13917979", "receipt_gas_used": "41309", "receipt_status": "1", "transaction_fee": "0.000562759624582009", "transaction_index": "75", "value": "0", "receipt_contract_address": null, "nft_transfers": [], "erc20_transfers": [ { "token_name": "Tether USD", "token_symbol": "USDT", "token_logo": " "token_decimals": "6", "from_address": "0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f", "from_address_entity": null, "from_address_entity_logo": null, "from_address_label": null, "to_address": "0x28c6c06298d514db089934071355e5743bf21d60", "to_address_label": "Binance 14", "to_address_entity": "Binance", "to_address_entity_logo": " "address": "0xdac17f958d2ee523a2206206994597c13d831ec7", "log_index": 338, "value": "50000000000", "possible_spam": false, "verified_contract": true, "direction": "send", "value_formatted": "50000" } ], "method_label": "transfer", "native_transfers": [], "summary": "Sent 50,000 USDT to Binance 14", "possible_spam": false, "category": "token send" }, //... } ] }
eth_getTokenPrice
The eth_getTokenPrice
methodology permits you to seamlessly retrieve the value of any token utilizing RPC-style requests. This eliminates the necessity to contain third-party API suppliers when integrating value information into your dapps. Right here’s the eth_getTokenPrice
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_getTokenPrice", "params": [ { "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7", "include": "percent_change" } ] }) }; fetch(‘YOUR_NODE_URL’, choices) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));
In response to working the script above, you’ll obtain the USD and native value of the desired token. Moreover, the response is enriched with token logos, value modifications over time, spam indicators, and extra. Right here’s what it would seem like:
{ //... end result: { tokenName: 'Tether USD', tokenSymbol: 'USDT', tokenLogo: ' tokenDecimals: '6', nativePrice: { worth: '375760131462618', decimals: 18, identify: 'Ether', image: 'ETH', tackle: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2' }, usdPrice: 1.0000402502911871, usdPriceFormatted: '1.000040250291187229', '24hrPercentChange': '-0.04543241491797881', exchangeName: 'Uniswap v3', exchangeAddress: '0x1F98431c8aD98523631AE4a59f267346ea31F984', tokenAddress: '0xdac17f958d2ee523a2206206994597c13d831ec7', priceLastChangedAtBlock: '20534105', possibleSpam: false, verifiedContract: true, pairAddress: '0xc7bbec68d12a0d1830360f8ec58fa599ba1b0e9b', pairTotalLiquidityUsd: '7148031.13' } }
In the event you’d like to be taught extra about our different strategies, please try the official Prolonged RPC Strategies documentation web page.
Exploring Moralis’ Web3 APIs
Moralis is Web3’s main information supplier, and as well as to next-generation RPC nodes, we additionally supply a complete suite of Web3 APIs. Some distinguished examples right here included the Wallet API, Token API, Streams API, and plenty of extra. As such, when leveraging Moralis, you get all crypto information in a single place.
What makes our APIs particular?
- Complete: Our APIs present the business’s most complete responses, providing you with extra information with fewer calls. Get token balances, any pockets’s transaction historical past, NFT costs, and way more with single requests.
- Cross-Chain: Moralis’ Web3 APIs are cross-chain suitable, offering full function parity throughout all main chains, together with Ethereum, BSC, Optimism, Base, and plenty of extra.
- Safe: Moralis holds a SOC 2 Sort 2 certification, demonstrating our dedication to safety and reliability.
Now, let’s dive a bit deeper into our Web3 API suite by exploring a few of our distinguished interfaces!
Moralis’ Web3 API Suite
In our suite of Web3 APIs, you’ll discover a number of interfaces tailor-made for varied use circumstances. Listed here are 5 distinguished examples:
- Wallet API: Get any pockets’s full historical past, token balances with costs, internet value, profitability, and way more with single requests. That is the right instrument for anybody wanting to construct Web3 wallets or combine pockets performance into dapps.
- Token API: Fetch token balances with costs, metadata, transactions, and way more with ease. That is your go-to answer for ERC-20 information, serving to you construct every little thing from portfolio trackers to DEXs.
- NFT API: Question NFT balances, costs, up-to-date metadata, transactions, and way more utilizing single strains of code. This instrument is superb for anybody wanting to construct NFT marketplaces, Web3 video games, or different comparable platforms.
- Worth API: Get real-time and historic costs for each NFTs and ERC-20 tokens. The Worth API is the last word instrument when you’re wanting to combine value information into your dapps.
- Streams API: The Streams API is Moralis’ real-time information answer, permitting you to arrange Web3 information pipelines on the click on of a button. That is the very best API for organising real-time alerts, populating databases with current on-chain occasions, or just integrating present information into dapps.
Please try the official Web3 API web page to be taught extra about our interfaces!
Abstract: How to Get Wallet Transactions Using RPC Nodes
Suppose you need to construct Web3 tasks like portfolio trackers, tax platforms, wallets, or different comparable dapps. In that case, chances are high that you simply’ll want entry to your customers’ native transaction historical past. Nonetheless, fetching this information utilizing RPC nodes is kind of difficult, because it requires a number of requests and a variety of guide information aggregation. Nonetheless, now you can get this information with only one name when utilizing Moralis’ Prolonged RPC Strategies.
With our Prolonged RPC Strategies, you will get decoded, human-readable information via RPC-style requests. Get pockets transactions, decoded pockets historical past, token balances, costs, and way more with single calls.
For example, that is how simple it’s to get pockets transactions utilizing RPC nodes when constructing with Moralis:
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_getTransactions", "params": [ { "address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "limit": 100, } ] }) }; fetch('YOUR_NODE_URL', choices) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));
In return for calling the script above, you get the native transaction historical past of the desired pockets, enriched with timestamps, gasoline costs, tackle labels, and extra. Right here’s a pattern response:
{ //... end result: [ { hash: '0xd89b02f289a08ae7b2feead06031fec20777bad8b73fc8d853f9040bc423a6c7', nonce: '0', transaction_index: '142', from_address: '0xda74ac6b69ff4f1b6796cddf61fbdd4a5f68525f', from_address_label: '', to_address: '0xdac17f958d2ee523a2206206994597c13d831ec7', to_address_label: 'Tether USD (USDT)', value: '0', gas: '207128', gas_price: '17020913648', input: '0xa9059cbb00000000000000000000000028c6c06298d514db089934071355e5743bf21d6000000000000000000000000000000000000000000000000000000017a1df1700', receipt_cumulative_gas_used: '8270587', receipt_gas_used: '41309', receipt_contract_address: null, receipt_root: null, receipt_status: '1', block_timestamp: '2023-01-22T15:00:11.000Z', block_number: '16463098', block_hash: '0x2439330d0a282f9a6464b0aceb9f766ac4d7b050c048b4a1322b48544c61e01d', transaction_fee: '0.000703116921885232' }, //... ] } }
That’s it! You now know the way to get pockets transactions utilizing RPC nodes!
In the event you discovered this tutorial attention-grabbing, contemplate testing extra content material on the weblog. For example, you’ll be able to learn the way to get DeFi protocol information or discover the ins and outs of QuickNode Streams.
Moreover, if you need to use the Prolonged RPC Strategies your self, don’t neglect to join an account with Moralis. You possibly can create your account without cost, and also you’ll get immediate entry to all our premier improvement instruments!