DRPC RPC — Pi Agent Setup Overlay
A Pi Agent-specific bootstrap for DRPC blockchain RPC: auto-configures MCP and acquires an API key via x402 wallet signing, so your agent works across 200+ networks from the first ask.
The skill explicitly forbids asking for private keys in Pi, prefers Coinbase Agentic Wallet so custody stays outside Pi, discloses data flow (writes ~/.pi/agent/mcp.), and provides a direct HTTP fallback; however, the flow installs an external MCP (Coinbase Payments) and rewrites config automatically without documented confirmation or rollback, and the extension implementation is not present in evidence — deducted.
Steps are clear with failure branches (prompt reload if MCP invisible, fallback to direct HTTP when unavailable), giving basic failure feedback; but the drpc_setup and drpc_coinbase_wallet_setup implementations are outside the evidence, with no tests or edge cases, so key-path reproducibility cannot be verified statically — deducted.
Trigger conditions are fairly explicit (blockchain data, DRPC setup, x402 key acquisition, missing DRPC MCP) and non-fit is declared (Pi Agent only); but core function depends entirely on overseas services (drpc.org, x402/Base on-chain settlement), a material reachability risk from mainland China — deducted.
Docs are well layered (overlay separated from the generic skill), MIT license is clear, and package. gives install/dependency notes; but the skill hard-depends on extension and sibling files not shown in evidence, versioning is bare (0.1.0) with no changelog or maintenance statement — deducted.
The claimed value — automated DRPC MCP configuration and x402 key acquisition reducing manual setup — is plausible; but with zero execution evidence, output usability and actual outcomes (including possible 5 USDC payment) are unverified — deducted.
Auditable primary material exists (SKILL.md, README, package., LICENSE) making the flow traceable; but key claims (MCP tool behavior, x402 flow) lack tests or third-party execution corroboration, and coverage is thin — deducted.
- The skill auto-installs and configures an external MCP server (Coinbase Payments) and rewrites ~/.pi/agent/mcp.; review install contents and rollback options before use.
- The x402 flow may trigger an on-chain payment (up to 5 USDC on Base for new wallets); understand the cost path beforehand.
- Core function depends on drpc.org and overseas blockchain services, which may be unreachable from mainland-China networks.
- The Pi extension code and the sibling drpc-rpc skill are outside the reviewed evidence; their safety and quality are unverified.
- Publisher is not verified by FollowSkills and identity is unknown; this is a static source review with nothing executed.
What does this skill do, and when should you use it?
This is a Pi Agent-specific skill from the drpcorg/drpc-agent-skills repository, designed as a setup overlay on top of the generic drpc-rpc skill. When DRPC MCP is missing from a Pi session, it drives an automated flow using the bundled Pi extension: it installs the Coinbase Payments MCP, acquires a DRPC API key over the x402 protocol, and writes the DRPC MCP into ~/.pi/agent/mcp.. Users are never asked for private keys — wallet custody stays outside Pi. It only works when the repository is installed as a Pi package with the extension loaded; copied elsewhere, the agent-callable tools it relies on simply don't exist.
Checks the Pi session's MCP server list; if DRPC MCP is missing and the drpc_setup tool exists, calls drpc_setup with no apiKey to install and configure the Coinbase Payments MCP; guides the user to reload or restart the session so payments-mcp becomes visible; uses payments-mcp to acquire a DRPC API key via x402 (SIWE signature or EIP-3009 payment); calls drpc_setup again with the key to write DRPC MCP into ~/.pi/agent/mcp.; if DRPC MCP is still unavailable in the current session, falls back to the generic direct HTTP mode from skills/drpc-rpc/direct-http.md to complete the request.
- A Pi Agent user who just installed the skill package needs DRPC MCP configured automatically on their first blockchain query
- A developer with a crypto wallet wants the agent to obtain its own API key, skipping signup and manual key copy-paste
- A security-conscious user refuses to paste private keys into Pi and prefers the Coinbase Agentic Wallet for x402 payments
- A user whose newly written MCP server isn't visible yet needs to know when to reload and how the request is served in the meantime via direct HTTP
- A developer maintaining multi-agent setups wants platform-specific Pi initialization kept separate from the generic drpc-rpc skill
What are this skill's strengths and limitations?
- Fully automated onboarding: MCP configuration and API key acquisition happen without restarts or config-file editing
- Sound security posture: explicitly forbids asking for private keys in Pi; wallet signing goes through Coinbase Payments MCP, keeping custody outside Pi
- x402 flow has a free shortcut: SIWE wallet sign-in against an already-linked DRPC account returns a key instantly at no cost
- Clear failure handling: prompts for session reload when MCP isn't visible and falls back to direct HTTP so the request never stalls
- Strictly Pi Agent-specific: the drpc_setup tools come from the Pi extension, so this file cannot work standalone in Claude Code, Cursor, or other platforms
- Newly written MCP servers require a session reload or restart to become visible, which can interrupt the first-run flow
- New wallets must pay 5 USDC (EIP-3009, settled on Base) for a key; without a wallet the flow falls back to manual signup
- No test suite or independent verification is shown in the source; reliability depends on the Pi extension's implementation
- This file is only an overlay — the actual RPC capabilities and 16 MCP tools live in the generic drpc-rpc skill, not here
How do you install this skill?
Inside a Pi Agent environment, run:
pi install npm:pi-mcp-adapter
pi install https://github.com/drpcorg/drpc-agent-skills
Pi-specific setup ships as a Pi extension documented in the repository's .pi/INSTALL.md (contents not included in the source material; consult that file for details). The skill only activates when the repo is installed as a Pi package with its extension loaded.
How do you use this skill?
Usually no manual trigger is needed: when the user asks for blockchain data, DRPC setup, x402 key acquisition, or Coinbase Payments MCP matters in Pi, the agent applies this skill. Manual commands are also available: /drpc-setup (configure a DRPC API key) and /drpc-coinbase-wallet-setup (configure Coinbase Payments MCP). Example prompt: "Get the ETH balance of vitalik.eth on Ethereum". If DRPC MCP is still not visible after key acquisition, the agent executes the request via direct HTTP instead.
How does this skill compare with similar options?
The README positions it as a platform-specific companion to the generic drpc-rpc skill: drpc-rpc handles generic blockchain RPC behavior, while this skill only handles setup inside Pi Agent. The choice is simple: use this only in Pi Agent; other platforms should use skills/drpc-rpc/ directly.