# Cronoscan Block Explorer MCP

> Cronoscan (Cronos Block Explorer) lets you analyze any data on the Cronos blockchain through conversation. Check CRO balances, track NFT transfers, inspect smart contract code, or run advanced RPC calls like `eth_call`—all without leaving your AI client.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** cronos, block-explorer, web3, smart-contracts, crypto-analytics

## Description

Need to figure out what actually happened with a token transfer? This MCP connects directly to the Cronos network data, letting you analyze everything from simple wallet balances to deep contract logic. You talk to it naturally, and it returns raw blockchain facts. Instead of digging through explorer tabs for transaction history or spending hours trying to locate source code, your agent handles the query. It monitors ERC-20 token movements, tracks NFT ownership changes, and even lets you run complex Ethereum calls—all in one place. If you're building tools that interact with Web3 data, Vinkius makes this MCP available so any compatible AI client can use it.

## Tools

### get_balance_multi
Retrieves CRO balances for several addresses at once.

### get_balance
Checks the current CRO balance held by one address.

### get_eth_price
Gets the current market price data for CRO.

### get_eth_supply
Determines the total circulating supply of CRO on the Cronos network.

### get_abi
Retrieves the Application Binary Interface (ABI) for a specific smart contract.

### get_block_reward
Finds out the block rewards associated with a specific block number.

### get_logs
Retrieves raw, detailed event logs for a contract's activity.

### get_source_code
Fetches the original source code of verified smart contracts.

### get_tx_receipt_status
Confirms the final status and receipt details of a transaction hash.

### proxy_eth_block_number
Retrieves the current block number on the network.

### proxy_eth_call
Simulates calling a contract function without actually executing it, useful for testing logic.

### proxy_eth_estimate_gas
Predicts the estimated gas cost required to execute a transaction.

### proxy_eth_gas_price
Gets the current recommended gas price for transactions.

### proxy_eth_get_block_by_number
Fetches all data contained within a specific block number.

### proxy_eth_get_code
Reads the compiled bytecode of a contract at a given address.

### proxy_eth_get_storage_at
Checks the value stored at a specific key within a contract's storage slots.

### proxy_eth_get_transaction_by_hash
Retrieves all details about a transaction using its unique hash.

### proxy_eth_get_transaction_receipt
Fetches the final, detailed receipt confirming if and how a transaction finished.

### get_token_balance
Checks how much a specific ERC-20 token is held by an account, given the contract address.

### get_token_nft_tx
Lists all transfer events for NFTs (ERC-721) associated with an address.

### get_token_supply
Calculates the total supply of a specific ERC-20 token using its contract address.

### get_token_tx
Lists all standard transfer events for an ERC-20 token by address.

### get_tx_list_internal
Retrieves internal transactions for an address, showing deeper contract interactions.

### get_tx_list
Gets a list of normal transactions that occurred at a specified address.

## Prompt Examples

**Prompt:** 
```
What is the current CRO balance for address 0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990?
```

**Response:** 
```
I've checked the balance for that address. It currently holds 1,250.45 CRO.
```

**Prompt:** 
```
Show me the last 5 ERC-20 token transfers for 0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990.
```

**Response:** 
```
I've retrieved the recent ERC-20 transfers. The most recent ones include 500 USDC and 100 VVS tokens. Would you like the transaction hashes for these?
```

**Prompt:** 
```
Get the ABI for the contract at 0x5C7C6f200567e573C96E38557b2062993894f91a.
```

**Response:** 
```
I have successfully fetched the ABI for that contract. It includes functions like `stake`, `withdraw`, and `claimRewards`. I can help you format a specific call if needed.
```

## Capabilities

### Track Wallet Balances
Check the current CRO balance for single or multiple addresses.

### Audit Token Flows
View all ERC-20 and NFT transfers, check total supply metrics, or retrieve specific transaction logs for an address.

### Inspect Contract Logic
Fetch contract source code, read the ABI, or run deep Ethereum calls to simulate function execution on a given contract.

### Monitor Network Status
Get real-time data points like current gas prices, block rewards, and market pricing for CRO.

## Use Cases

### Investigating a Failed Transfer
A user sees an asset transfer failed. Instead of manually checking the explorer, they ask their agent to use `proxy_eth_get_transaction_by_hash` and then check the final status using `get_tx_receipt_status`. This confirms if the failure was due to gas limits or contract logic.

### Auditing a Smart Contract
A developer needs to audit a new smart contract. They first use `get_abi` and `get_source_code` to understand its intent, then run `proxy_eth_call` multiple times with edge-case inputs to test every function before writing any code.

### Tracking Whale Movements
An analyst wants to know if a large wallet is moving assets. They ask the agent to list all recent transfers using `get_token_nft_tx` and cross-reference that with CRO balances reported by `get_balance_multi`.

### Calculating Total Portfolio Value
A DeFi user wants a total value report. They prompt the agent to check all holdings, triggering checks for both native tokens (`get_balance`) and multiple ERC-20 types (`get_token_balance`), providing one consolidated number.

## Benefits

- Stop jumping between tools. You can check a user's total portfolio value by combining `get_balance` and `get_token_balance` in one conversation flow.
- Don't guess if a contract will work. Use `proxy_eth_call` to simulate function execution before committing gas, saving you time and money.
- When debugging complex transactions, you don't just see the outcome; you get raw data logs via `get_logs`, which is crucial for finding subtle failures.
- You can track asset ownership changes by combining transfers using `get_token_nft_tx` with standard transaction lists from `get_tx_list`.
- It gives you a full picture of network costs, letting you use `proxy_eth_estimate_gas` alongside `get_eth_price` to budget accurately.
- Getting the contract blueprint is simple. You can fetch both the source code via `get_source_code` and its structure using `get_abi` instantly.

## How It Works

The bottom line is: it turns complex blockchain queries into simple natural language prompts.

1. Subscribe to this MCP on Vinkius and provide your Cronoscan API key.
2. Instruct your AI client what data you need—for example, 'What was the balance of this address last week?'
3. The agent uses the appropriate tools to query the blockchain and returns the analyzed result directly in chat.

## Frequently Asked Questions

**How do I check multiple wallet balances with Cronoscan (Cronos Block Explorer) MCP?**
Use the `get_balance_multi` tool. This is much faster than calling `get_balance` repeatedly for every single address you need to track.

**Can I simulate a contract call without actually paying gas using proxy_eth_call?**
Yes, that's exactly what `proxy_eth_call` does. It simulates the function execution logic and result without spending any real network funds or affecting the state.

**What is the difference between get_logs and get_source_code?**
`get_logs` provides raw, technical event data emitted during contract activity. `get_source_code` gives you the human-readable code written by the developer.

**How do I track internal transactions for an address using Cronoscan (Cronos Block Explorer) MCP?**
Use the `get_tx_list_internal` tool. This shows you the deeper, nested calls that happen when one contract interacts with another.

**How do I calculate the required gas limit using proxy_eth_estimate_gas?**
It returns an estimate of the maximum gas needed for a transaction. You use this number to set your gas limit, preventing failed transactions due to insufficient funds.

**When should I use proxy_eth_get_storage_at?**
You run this when you need to read data stored directly at a specific slot within the contract's storage. This lets you check internal state variables not exposed by standard functions.

**How does get_tx_receipt_status help me debug a failed transaction?**
It checks the full receipt status, telling you if the transaction succeeded or reverted. This is crucial for debugging when simple listing tools don't provide enough detail.

**How can I track all NFT movements using get_token_nft_tx?**
This tool tracks every ERC-721 transfer event associated with a specific address. It gives you a complete, chronological history of ownership changes for your NFTs.

**Can I check the CRO balance of multiple wallet addresses in a single request?**
Yes! Use the `get_balance_multi` tool by providing a comma-separated list of addresses. The AI will return the current balance for each address in the list.

**How do I retrieve the source code of a verified smart contract on Cronos?**
You can use the `get_source_code` tool with the contract's address. If the contract is verified on Cronoscan, the AI will fetch the source code, compiler version, and other optimization details.

**Is it possible to track NFT transfers for a specific user?**
Absolutely. Use the `get_token_nft_tx` tool with the user's wallet address. You can also filter by a specific NFT contract address to narrow down the results.