Hive Intelligence home
Hive Intelligence
GitHub

Workflows & Recipes

Cross-chain wallet analysis for AI agents

Written by Rishabh Narang, CEO, Hive IntelligenceLast updated

The problem

Your AI agent needs a cross-chain wallet brief - 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?"

python
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.

python
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)
    r.raise_for_status()
    payload = r.json()
    if not payload.get("ok", False):
        raise RuntimeError(payload.get("error", {}).get("message", "Hive call failed"))
    return payload["data"]

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, "chain": "eth"})
nfts = hive("alchemy_get_nfts_by_wallet", {"address": wallet, "network": "eth-mainnet"})
txns = hive("moralis_get_wallet_history", {"address": wallet, "chain": "eth", "limit": 10})

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

Available wallet tools

ToolWhat it returns
alchemy_get_token_balances_by_walletEVM token balances with network context
moralis_get_wallet_defi_positionsActive DeFi positions (lending, staking, LP)
alchemy_get_nfts_by_walletNFT holdings with metadata
moralis_get_wallet_historyTransaction history across chains
get_wallet_balancesToken balances (default surface)
get_wallet_token_balancesDetailed 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 APIs. 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.

python
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 wallet brief 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:

python
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, with no additional auth.

Why this matters

  • One API key replaces two. You connect through Hive instead of holding separate Moralis and Helius accounts.
  • Consistent auth. Every call uses the same Authorization: Bearer header.
  • Less schema merging. Your agent builds a wallet brief without reconciling three different response formats across EVM and Solana.
  • Provider flexibility. If Hive adds a better wallet data source tomorrow, runtime discovery and normalized execution metadata reduce the amount of provider-specific code you need to maintain.
  • 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.
Next
DeFi Yield Research