# Nodereal MCP > Nodereal connects your AI client directly to high-performance blockchain infrastructure supporting both Aptos and EVM chains. Your agent can query account details, read block histories, and simulate transactions across major smart contract networks instantly. Access everything from Move module data on Aptos to gas estimates on Ethereum. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** aptos, ethereum, evm, rpc, web3, infrastructure ## Description Look, you need an AI agent that can actually talk blockchain, and Nodereal gives it the keys to both Aptos and EVM chains. Your agent connects directly to high-performance infrastructure, so you don't gotta build some clunky RPC wrapper yourself; just hook up your client and let it go. You’ll get full access to everything—from Move module specifics on Aptos to gas estimates for Ethereum. **Reading Account State** Your agent can grab detailed info on specific accounts. For Aptos, you've got `aptos_get_account` which pulls general high-level details using just an address. If you need the fine print, `aptos_get_account_modules` lists every Move module tied to that account. You can also check exactly what’s in the vault with `aptos_get_account_resources`, or retrieve the full set of resources held by any given Aptos wallet. On the EVM side, you'll get balances using `eth_get_balance` for a specific address. You can run checks on ERC20 tokens specifically with `nr_get_token_balance_20`, and if you need to know who owns these assets, `nr_get_token_holders` gives you that full list of addresses. **Simulating Transactions** Before you commit a dime, your agent can check the math. For Aptos, it runs through `aptos_simulate_transaction`, giving you an estimate and validating if the intended transaction actually executes. When dealing with EVM chains, you don't wanna waste gas; use `eth_estimate_gas` to calculate exactly how much fuel a specified transaction needs, or run a read-only message call using `eth_call` so you can test logic without spending anything. **Analyzing Transaction History** Figuring out what went down is crucial. For Aptos, your agent retrieves all details about a specific operation with `aptos_get_transaction_by_hash`, or it can fetch general lists of recent activity using `aptos_get_transactions`. If you want to dig into the raw data on an EVM chain, `eth_get_logs` lets you filter and grab event logs that match your criteria. You can also use `eth_get_transaction_receipt` to pull the full receipt confirming a transaction's execution. NodeReal supercharges this history review: `nr_get_transaction_receipts_by_block_number` pulls receipts for all transactions within a specific block number, and you can get an asset transfer history linked to any address using `nr_get_asset_transfers`. If you need to know which NFTs are floating around, `nr_get_nft_holders` lists every address holding a certain collection, while `nr_get_nft_inventory` pulls the specific list of IDs and NFTs held by one address. **Querying Network Metadata** You gotta keep track of the clock. For context checks, you can grab the current ledger state with `aptos_get_ledger_info`. On the Aptos side, if you need a snapshot of the network at a specific point, `aptos_get_blocks_by_height` fetches all blocks matching a given height number. For EVM chains, your agent checks the latest block using `eth_block_number`, and it can retrieve all data contained within any specific block via `eth_get_block_by_number`. You also get the unique ID of the currently connected network through `eth_chain_id`. **Sending Data & Debugging** If you need to write something or check a weird path, your agent handles it. On Aptos, if you’re debugging an issue, `debug_trace_transaction` traces the full execution path of any transaction on an EVM-compatible chain. For sending data, you can submit a signed, raw transaction using `eth_send_raw_transaction` to create new calls or contracts on the EVM side. Basically, your agent doesn't just read; it runs diagnostics, tracks assets—like running `nr_get_asset_transfers` for history or checking who owns what with `nr_get_nft_inventory`—and gets critical network data from both Aptos and EVM. It’s the deep-dive toolset you need. ## Tools ### aptos_get_account_modules Lists all Move modules associated with an Aptos account. ### aptos_get_account_resources Retrieves every resource currently held by a specific Aptos account. ### aptos_get_account Gets general high-level details for a specific Aptos account address. ### aptos_get_blocks_by_height Fetches all blocks from the Aptos network corresponding to a given height number. ### aptos_get_ledger_info Gets the current, overall state information for the entire Aptos ledger. ### aptos_get_transaction_by_hash Retrieves all details about an Aptos transaction using its unique hash identifier. ### aptos_get_transactions Fetches a general list of recent or filtered transactions on the Aptos network. ### aptos_simulate_transaction Estimates gas and validates if an intended Aptos transaction will execute successfully before you spend money. ### debug_trace_transaction Traces the full execution path of a transaction on an EVM-compatible chain. ### eth_block_number Returns the current, latest block number for the configured EVM network. ### eth_call Executes a read-only message call on an EVM chain without creating any actual transaction or spending gas. ### eth_chain_id Gets the unique ID number for the currently connected EVM network (e.g., mainnet, testnet). ### eth_estimate_gas Calculates and returns an estimate of how much gas is needed for a specified transaction. ### eth_get_balance Retrieves the current token balance for any given EVM address. ### eth_get_block_by_number Fetches all data contained within a specific block, identified by its number on an EVM chain. ### eth_get_logs Filters and retrieves event logs that match specific criteria across the EVM blockchain. ### eth_get_transaction_receipt Retrieves the detailed receipt confirming a transaction's execution on an EVM chain. ### eth_send_raw_transaction Submits a signed, raw transaction to create a new message call or contract creation record (EVM). ### nr_get_asset_transfers Gets a history of asset transfers linked to a specific address using NodeReal's enhanced data. ### nr_get_nft_holders Lists all addresses that currently hold any NFT from a defined collection (NodeReal Enhanced). ### nr_get_nft_inventory Retrieves the specific list of NFTs and their IDs held by one address (NodeReal Enhanced). ### nr_get_token_balance_20 Checks the token balance for an ERC20 standard token using NodeReal's enhanced toolset. ### nr_get_token_holders Gets a full list of addresses that hold any tokens from a specific contract (NodeReal Enhanced). ### nr_get_transaction_receipts_by_block_number Fetches all transaction receipts recorded within a specified block number using NodeReal's enhanced toolset. ## Prompt Examples **Prompt:** ``` Get the current block number for the configured EVM network. ``` **Response:** ``` I've queried the network using `eth_block_number`. The current block height is 18,452,103. ``` **Prompt:** ``` Retrieve account information for Aptos address 0x1. ``` **Response:** ``` Using `aptos_get_account`, I found that address 0x1 has a sequence number of 5234 and an authentication key ending in ...a3f2. ``` **Prompt:** ``` Check the ETH balance for address 0x742d35Cc6634C0532925a3b844Bc454e4438f44e. ``` **Response:** ``` I've executed `eth_get_balance`. The balance for that address is 1.25 ETH (represented as 1250000000000000000 wei). ``` ## Capabilities ### Read Account State The agent retrieves detailed information on specific accounts, including resources, modules, and balances for both Aptos and EVM chains. ### Simulate Transactions You estimate gas costs and check execution logic using tools like `aptos_simulate_transaction` before committing any funds to the network. ### Analyze Transaction History The agent fetches detailed transaction receipts, filters event logs by block number (`eth_get_logs`), or retrieves an entire list of transactions for investigation. ### Query Network Metadata You get critical network metrics—like the current block height, chain ID, or overall ledger info—for timing and context checks. ### Inspect Digital Assets The agent queries specialized NodeReal tools to list NFT holders or check specific ERC20 token balances for an address. ## Use Cases ### Auditing a Smart Contract A developer wants to see if a new token contract handles edge cases. They ask their agent to run `aptos_simulate_transaction` first, checking the gas cost and execution logic with specific inputs. The agent returns success or failure data immediately, letting the dev fix the code before deployment. ### Tracking NFT Liquidity A collector wants to know who holds a rare collection. They ask their agent to run `nr_get_nft_holders` and then cross-reference those addresses by calling `eth_get_balance` to see how much liquid ETH they have available. ### Investigating an Incident A data analyst needs to understand a transfer that happened last week. They use the agent to call `eth_get_logs` for a specific block number, filtering by contract address and event type. This quickly surfaces the critical transaction details needed for reporting. ### Checking Account Status A DevOps engineer needs to confirm network health. They ask their agent for `eth_block_number` (for EVM) or `aptos_get_ledger_info` (for Aptos). This confirms connectivity and allows them to know if the chain is functioning normally. ## Benefits - Stop guessing gas costs. Use `aptos_simulate_transaction` or `eth_estimate_gas` to validate execution logic before you commit funds, saving time and money on every test run. - Consolidate cross-chain data checks. You can query an NFT holder list using `nr_get_nft_holders`, then immediately check their ETH balance with `eth_get_balance`—all in one workflow. - Deeply inspect contract behavior. Tools like `debug_trace_transaction` allow you to see the exact execution path of a smart contract, not just the final result. - Streamline historical analysis. Instead of querying logs manually, use `eth_get_logs` to filter and fetch all relevant event data for a given block number or address. - Simplify asset tracking. The enhanced NodeReal tools (`nr_get_asset_transfers`, `nr_get_nft_inventory`) provide clear views into an address's holdings that standard RPC calls miss. ## How It Works The bottom line is: your AI client talks to one endpoint, and that endpoint handles all the complex connections needed for both Aptos and Ethereum-style queries. 1. Subscribe to the Nodereal server and input your API Endpoint URL into your AI client. 2. Ask your agent a question, such as 'What was the gas cost of transaction hash X?' 3. The agent translates that query into the correct tool call (e.g., `eth_get_transaction_receipt`), executes it via Nodereal, and returns the structured data. ## Frequently Asked Questions **How do I simulate a transaction on Aptos using aptos_simulate_transaction?** You pass the necessary inputs (source, destination, payload) to `aptos_simulate_transaction`. The tool returns an estimate of gas cost and confirms if the execution logic is valid before you actually spend anything. **Can I get asset transfers using nr_get_asset_transfers?** Yes. `nr_get_asset_transfers` retrieves a history of assets that moved to or from a specific address, giving you a comprehensive view beyond just token balances. **What is the difference between aptos_get_account and aptos_get_account_resources?** `aptos_get_account` gives high-level data (like sequence number). `aptos_get_account_resources` goes deeper, listing every specific resource type attached to that account. **How do I check token balances on EVM? Do I need eth_get_balance?** Yes, `eth_get_balance` is the main tool. However, for specialized ERC20 tokens, use `nr_get_token_balance_20` to ensure you're getting the correct balance data. **If I'm debugging an EVM smart contract interaction, how do I use `eth_get_logs` to filter for specific events?** You pass a detailed filter object containing addresses or topic hashes. This lets you pull only the targeted event logs from massive amounts of block data. It’s essential for tracing complex interactions across multiple contracts. **What critical network state information do I get when I use `aptos_get_ledger_info`?** It provides a comprehensive snapshot of the current Aptos ledger status. You'll find key metrics like the latest block height, total supply data, and overall chain health indicators. This is perfect for monitoring network stability. **When I use `eth_estimate_gas`, how accurate is the gas calculation before I send a transaction?** It gives a precise calculation of the computational cost needed to execute the specific logic. The estimate helps you avoid running out of funds, saving time and preventing failed transactions on the live network. **If I need to understand an account's full programming capabilities, what does `aptos_get_account_modules` show me?** It lists every Move module associated with that specific address. This tells you exactly which contracts or libraries the account has access to and interacts with. It’s key for understanding its underlying permissions. **Can I check the resources associated with an Aptos account?** Yes, you can use the `aptos_get_account_resources` tool by providing the account address to see all Move resources stored on that account. **How do I retrieve logs for a specific smart contract on an EVM chain?** Use the `eth_get_logs` tool. You will need to provide a JSON filter object containing parameters like the contract address and block range. **Is it possible to test an Aptos transaction without actually sending it?** Absolutely. The `aptos_simulate_transaction` tool allows you to submit a transaction payload to see if it would succeed and how much gas it would consume.