The Problem

Your AI agent needs a complete wallet profile - token balances, net worth, DeFi positions, transaction history, and NFTs - across multiple chains. That data typically lives across separate APIs with different schemas and auth flows.

Without Hive

Integrate one API for balances, DeFi positions, and NFTs. Integrate another for multichain transactions. Two APIs, two accounts, two schemas, and custom merging logic before your agent can answer "what does this wallet look like?"

import requests

# Source A: wallet overview
headers_a = {"X-API-Key": "SOURCE_A_KEY"}
net_worth = requests.get("https://api-a.example/wallets/0xWALLET/net-worth",
    headers=headers_a).json()
defi = requests.get("https://api-a.example/wallets/0xWALLET/defi/positions",
    headers=headers_a).json()
nfts = requests.get("https://api-a.example/0xWALLET/nft",
    headers=headers_a).json()

# Source B: transactions (different API, different auth)
headers_b = {"Authorization": "Bearer SOURCE_B_KEY"}
txns = requests.get("https://api-b.example/v1/1/address/0xWALLET/transactions/",
    headers=headers_b).json()

That is roughly 35 lines once you add error handling, schema normalization, and merge logic - and it breaks every time either source changes their response format.

With Hive

Five tool calls through one connection. One API key. Consistent auth.

import requests

def hive(tool, args):
    r = requests.post("https://mcp.hiveintelligence.xyz/api/v1/execute",
        headers={"Authorization": "Bearer YOUR_HIVE_API_KEY"},
        json={"tool": tool, "args": args}, timeout=30)
    return r.json()

wallet = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"  # vitalik.eth
balances = hive("alchemy_get_token_balances_by_wallet", {"address": wallet, "network": "eth-mainnet"})
defi = hive("moralis_get_wallet_defi_positions", {"address": wallet})
nfts = hive("alchemy_get_nfts_by_wallet", {"address": wallet, "network": "eth-mainnet"})
txns = hive("moralis_get_wallet_history", {"address": wallet})

15 lines. No provider accounts to manage. No schema merging.

Available Wallet Tools

Tool	What it returns
`alchemy_get_token_balances_by_wallet`	EVM token balances with network context
`moralis_get_wallet_defi_positions`	Active DeFi positions (lending, staking, LP)
`alchemy_get_nfts_by_wallet`	NFT holdings with metadata
`moralis_get_wallet_history`	Transaction history across chains
`get_wallet_balances`	Token balances (default surface)
`get_wallet_token_balances`	Detailed token-level balance breakdown

EVM + Solana in One Wallet Profile

Real wallets hold both EVM and Solana assets. Hive's wallet surface spans both without switching SDKs — EVM chains (Ethereum, Base, Polygon, Arbitrum, Optimism, BSC) and Solana (native RPC + Digital Asset Standard for fungibles and compressed NFTs) are unified under one envelope.

def full_profile(address):
    is_solana = not address.startswith("0x")  # crude check; use a real validator in prod
    if is_solana:
        balance  = hive("helius_get_balance",          {"address": address})
        tokens   = hive("helius_get_token_balances",   {"owner": address})
        assets   = hive("helius_get_assets_by_owner",  {"ownerAddress": address, "limit": 50})
        # assets includes compressed NFTs — unique to Solana DAS
        return {"chain": "solana", "sol": balance, "tokens": tokens, "assets": assets}

    # EVM path
    return {
        "chain":        "evm",
        "balances":     hive("alchemy_get_token_balances_by_wallet",      {"address": address, "network": "eth-mainnet"}),
        "defi":         hive("moralis_get_wallet_defi_positions",         {"address": address}),
        "nfts":         hive("alchemy_get_nfts_by_wallet",                {"address": address, "network": "eth-mainnet"}),
        "transactions": hive("moralis_get_wallet_history",                {"address": address}),
    }

print(full_profile("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))  # vitalik.eth — EVM
print(full_profile("vitalik.sol"))                                 # Solana address — Helius path

Agents that support MCP skip the dispatch code entirely. Prompt Claude Code or Cursor:

"Build a complete wallet profile for 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045: token balances, DeFi positions, 30-day transaction history, and current NFT holdings. Return as markdown with a risk section."

Claude calls the right wallet tools in sequence, normalizes the output, and returns a citable brief. Add helius_get_token_accounts to the prompt for Solana depth.

Adding Pre-Action Safety

Wallet analysis agents that recommend moves (swap, stake, withdraw) should call a security tool before returning recommendations. Hive exposes the security check through the same API key:

def safe_recommendation(wallet, target_token):
    profile = full_profile(wallet)
    safety  = hive("get_token_security", {"contract_addresses": target_token, "chainId": "1"})
    rugpull = hive("detect_rugpull",         {"contract": target_token})
    if safety["data"]["is_honeypot"] or rugpull["data"]["score"] > 7:
        return {"recommendation": "skip", "reason": safety["data"]["summary"]}
    return {"recommendation": "proceed", "profile": profile}

This is the "grounded before signed transaction" pattern most wallet agents need — one more tool call through the same connection, no additional auth.

Why This Matters

One API key replaces two. No Moralis account, no Helius account — just Hive.
Consistent auth. Every call uses the same Authorization: Bearer header.
No schema merging. Your agent builds a complete wallet profile without reconciling three different response formats across EVM and Solana.
Provider flexibility. If Hive adds a better wallet data source tomorrow, your code does not change.
Runtime discovery. An MCP agent picks up new wallet tools through tools/list without a redeploy.
Built-in safety path. The same API key unlocks pre-signing security checks without bolting on a fourth provider.