# Shiden Scan MCP > Shiden Scan (Shiden Network Block Explorer) lets your AI agent read live data from the Shiden blockchain. You can query everything—blocks, accounts, contracts, and token prices—using natural language prompts. It's built for developers who need to debug complex smart contract interactions or track asset movements across multiple addresses without leaving their coding environment. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** shiden-network, block-explorer, substrate, evm-contracts, polkadot-ecosystem ## Description Listen up. This server lets your AI agent read live data straight from the Shiden blockchain. You're talking directly to the network; you don't need some fancy dashboard just to see what's going on. It treats complex blockchain state like a simple API call, so you can query everything—blocks, accounts, contracts, and token prices—using plain English prompts. If you're debugging smart contract interactions or tracking how assets move across multiple addresses, this is the toolset you need. Your agent uses these specific tools to pull data when you ask it to: **Auditing Account Status:** You can check any Shiden address with `get_account_info` to get its current balance, staked amount, and general metadata. Want a full picture? Use `list_transfers` for a chronological rundown of every value movement associated with that account. For deep dives into transaction history, you've got `list_blocks`, which spits out a list of recent block hashes; then you can select one to run `get_block` and retrieve all the detailed info about that specific block. **Tracking Activity:** To monitor network finality or track suspicious movements, your agent uses `list_extrinsics` for a roster of recent extrinsic transaction hashes. Need details on one of those transactions? `get_extrinsic` pulls every single detail you need. If you're following smart contract activity specifically, `list_evm_transactions` shows all EVM transactions that occurred within an address range belonging to a specific contract. **Analyzing Contracts:** When it comes to deployed logic, the server has `get_evm_contract`. This fetches metadata and transaction logs for any smart contract built using EVM standards on Shiden. You use this tool to see exactly what those contracts are doing. **Market Context & Assets:** To keep your fingers on the pulse of the market, you can run `get_token_price` anytime; it gives you the current market price and trading volume for the SDN token instantly. For foundational knowledge about the network itself—like figuring out what token decimals are or checking SS58 prefixes—you just use `get_metadata`. Every time your agent runs a query, it's translating your intent into structured calls across these tools. It gives you a clean, synthesized answer about complex blockchain state changes without leaving your coding environment. You don't just get data points; you get the whole story of what happened on Shiden. ## Tools ### get_account_info Gets the current balance, staked amount, and metadata for a specific account address. ### get_block Retrieves all detailed information about one specific block hash on the Shiden Network. ### list_blocks Generates a list of recent block hashes, allowing you to select specific ones for deep inspection. ### get_evm_contract Fetches metadata and logs for a smart contract deployed using EVM standards. ### list_evm_transactions Shows all EVM transactions that occurred within a specified smart contract's address range. ### get_extrinsic Retrieves all details for a single, specific extrinsic transaction on the network. ### list_extrinsics Provides a list of recent extrinsic transaction hashes for monitoring network activity. ### get_metadata Pulls general data about the Shiden Network itself (e.g., token decimals). ### get_token_price Retrieves the current market price and trading volume for the SDN token. ### list_transfers Retrieves a chronological list of all value transfers associated with a specific account. ## Prompt Examples **Prompt:** ``` List the most recent blocks on the Shiden Network. ``` **Response:** ``` I've retrieved the latest blocks. The most recent block is #5,402,123, finalized with 12 extrinsics and 45 events. Would you like to see the details of a specific block number? ``` **Prompt:** ``` What is the current balance and status of address ab12...c34? ``` **Response:** ``` For address ab12...c34, the total balance is 150.5 SDN. This includes 140.0 SDN transferable and 10.5 SDN bonded for staking. The account nonce is currently 42. ``` **Prompt:** ``` Show me the recent EVM transactions for the contract at 0x789...def. ``` **Response:** ``` I found 5 recent EVM transactions for that contract. The most recent one involved a 'Transfer' method call from 0xabc... to 0xdef... 2 minutes ago. Would you like to inspect the logs of a specific transaction? ``` ## Capabilities ### Audit Account State Fetch comprehensive balance and metadata details for any Shiden address. ### Inspect Block History Retrieve specific blocks or lists of recent blocks to track network activity and finality. ### Analyze Smart Contract Logic Fetch metadata, transaction logs, and history for deployed EVM smart contracts on Shiden. ### Track Asset Movements List all transfers or detailed extrinsics associated with a given account address. ### Get Network Context Retrieve overall network metadata, like token decimals and SS58 prefixes. ### Check Market Metrics Pull real-time price data and market capitalization for the SDN token. ## Use Cases ### Tracing a large fund transfer A client asks: 'Where did the 100 ETH go?' Your agent starts by calling `get_account_info` to confirm the initial balance. It then runs `list_transfers` on that address. Finally, it uses `get_extrinsic` on a suspicious hash to pinpoint the exact recipient and contract interaction. ### Verifying smart contract deployment A developer needs to confirm if a new version of their contract is live. They use `list_blocks` to find recent blocks, then `get_evm_contract` with the target address. This confirms not just that it exists, but what its metadata is. ### Checking node synchronization status A node operator needs quick confirmation of network health. They ask for the latest blocks and use `list_blocks`. If the block count or last known extrinsic hash looks off, they know immediately that sync is needed. ### Calculating collateral risk An analyst needs to assess if a pool has enough staked funds. They run `get_account_info` on the pool's primary address to get the bonded and reserved balances, giving an instant measure of capital backing. ## Benefits - Audit accounts instantly. Instead of going to a separate explorer, use `get_account_info` to get total balance (transferable, bonded, reserved) and transaction history all in one prompt. - Track network events efficiently. Use `list_blocks` or `list_extrinsics` when you need to monitor block finality or pinpoint specific transactions across the Shiden Network. - Debug contracts fast. When validating dApps, call `get_evm_contract` and `list_evm_transactions`. You get metadata and logs for any deployed contract right from your agent. - Monitor token value easily. Forget checking multiple exchange APIs; use `get_token_price` to grab the current SDN price and 24h trading volume instantly. - See complete history. Need proof of funds? Run `list_transfers` on an address. It gives you a clear, auditable list of every value movement associated with that account. ## How It Works The bottom line is you get deep blockchain data—from blocks to balances—by asking your AI client a simple question. 1. Subscribe to the server and enter your Shiden Scan API Key. 2. Your AI client sends a natural language query (e.g., 'What's the balance of address X?'). 3. The agent executes the necessary tools (`get_account_info`, `list_transfers`) and returns the consolidated, accurate answer. ## Frequently Asked Questions **How do I check the balance using get_account_info?** You just provide the SS58 address. The tool returns the total balance, broken down into transferable, bonded, and reserved amounts for that account. **What is the difference between list_blocks and list_extrinsics?** Blocks contain many things. `list_blocks` gives you the container (the block hash). `list_extrinsics` gives you a list of specific, actionable events that happened inside those blocks. **Can get_evm_contract show me transaction logs?** Yes. In addition to metadata, `get_evm_contract` fetches the transaction logs for deployed smart contracts. This is key for debugging contract execution paths. **Do I need get_metadata to use list_transfers?** While not strictly required to run the tool, running `get_metadata` first gives you context on token decimals and prefixes. This prevents common calculation errors when analyzing transfers. **When using get_account_info, how do I handle insufficient data or missing addresses?** The tool returns a specific error code and an empty payload if the address is invalid. Your agent must check for this status instead of assuming that no data means no assets. **If I run list_blocks repeatedly, are there rate limits I need to worry about?** Yes, API usage has defined rate limits. For large-scale analysis with list_blocks, your client should implement exponential backoff and retry logic in its code. **Does get_evm_contract provide the full bytecode or just metadata?** It primarily fetches structured metadata and transaction logs. If you need to analyze the raw, compiled bytecode itself for deep debugging, you'll need to consult an external compiler service. **What data scope does list_transfers cover? Does it track everything?** It tracks standard token transfers and account movements. For complex internal state changes within a contract that aren't simple transfers, you must use list_evm_transactions. **Can I check the balance of a specific Shiden address?** Yes! Use the `get_account_info` tool with the account address. The agent will return the transferable, bonded, and reserved balances, along with the account nonce. **How do I inspect a smart contract deployed on Shiden?** You can use `get_evm_contract` to fetch general contract details or `list_evm_transactions` to see the recent transaction history for a specific contract address. **Can I see the current market price of the SDN token?** Absolutely. The `get_token_price` tool retrieves the current price of SDN in USD and BTC, as well as its market cap and 24h volume.