OneSource MCP

Check ERC20 token allowance (approved spending amount) via the allowance(owner,spender) RPC call. Use this before executing transferFrom or to verify approvals. Returns the allowance amount in raw token units. Optional fields the response could not confirm are listed in warnings; a field that is missing or false for that reason is unknown for this response, not a confirmed answer.

View or change payment preferences and save them so they persist across restarts — no MCP config editing or restart required. Call with no arguments to see current settings. Set "prompt" (ask/auto/off — agent autonomy when switching to a cheaper channel mode), "threshold" (anticipated calls before a channel is worth it), "deposit_multiplier" (x402 channel deposit = call price × this; applies to the next channel opened), "mpp_max_deposit" (MPP session channel deposit cap, in tokens), or "mode" (the default rail+scheme — x402-exact / x402-batch / mpp-charge / mpp-session — also switched live for this session). Pass "reset": true to restore defaults. With an API key, calls are covered by your plan.

Get full block details by block number via RPC. Returns transactions, gas used, miner, timestamp, and other header fields. Accepts decimal (e.g. "21000000"), hex (e.g. "0x1406F40"), or a named tag ("latest", "pending", "earliest", "safe", "finalized").

Get the latest block number for a network. Returns the current chain head as a hex-encoded value. Use 1s_network_info to also get chain ID and gas price in the same call.

Get the EIP-155 chain ID for a network as a hex-encoded value. Use this to verify the network before signing transactions. Use 1s_network_info to get chain ID, block number, and gas price together.

Get the deployed bytecode of a contract via eth_getCode. Returns '0x' for EOA (non-contract) addresses. Bytecode can be very large for complex contracts. Prefer 1s_proxy_detect or 1s_contract_info_live for type checks without fetching full bytecode.

Detect contract type and supported interfaces via eth_getCode and ERC165 supportsInterface. Returns detected standards (ERC20, ERC721, ERC1155, ERC165). Optional fields the response could not confirm are listed in warnings; a field that is missing or false for that reason is unknown for this response, not a confirmed answer.

Get a Deepstate order-book snapshot for a market — bids descending, asks ascending, with each price level’s resting size. Reflects the last completed on-chain state read rather than every intervening block; the returned block number names exactly which height it was read at. Call 1s_ds_markets for the list of available book slugs.

Get Deepstate OHLCV candles for a market at a given timeframe. Open/high/low/close are real trade prices, not recomputed; volumes are exact sums. The most recent (still-open) bucket updates as new trades arrive; earlier buckets are final. Call 1s_ds_markets for the list of available book slugs.

Get gas spent resting and cancelling orders on a Deepstate market, bucketed over time — total fee, median fee, and how much of the fee is L2-to-L1 data cost. Requires a book — call 1s_ds_markets for the list of available book slugs.

Get a depth heatmap for a Deepstate market: resting order size by price level over time, bucketed and optionally restricted to one side. Each bucket also reports how much of it is covered by a sized order count, so a caller can tell how complete a given level is. Requires a book — call 1s_ds_markets for the list of available book slugs.

Get per-maker analytics for a Deepstate market over a time window: time spent at the top of book, current resting notional, fill count and fill rate, and DEEP rewards earned. Rows are keyed by maker (resting-order owner) address. Requires a book — call 1s_ds_markets for the list of available book slugs.

List the Deepstate markets (order books) this API serves, with each market’s slug, token layout, and pool/router addresses. Call this first: every other Deepstate tool takes a book identifier, and this is the source of truth for which books exist and their canonical uppercase slug form (e.g. "NVDA-USDG"). Static configuration data, safe to cache client-side.

Get rolling 24h / 7d / 30d volume and price change for a Deepstate market, plus the latest traded price. Call 1s_ds_markets for the list of available book slugs.

Get the Deepstate trade tape for a market, newest first — each fill’s price, size, side, and the block it happened in. Page backward in time with `before` (returns trades strictly below that block number). Call 1s_ds_markets for the list of available book slugs.

Resolve ENS names to addresses (forward) or addresses to ENS names (reverse). Accepts either a .eth name or a 0x address. Only works on networks with the ENS registry deployed: ethereum and sepolia. On robinhood the registry is absent, and the response is HTTP 200 with supported:false and an error naming the chain — that is a fact about the network, not evidence that the name is unregistered. Do not conclude a name has no resolver from a non-ENS chain.

Get real-time ERC1155 token balance via balanceOf(address,uint256) RPC call. Returns the raw balance as a numeric string.

Get real-time ERC20 token balance directly from the blockchain via balanceOf. Use this for pre-transaction checks or when zero indexing delay is needed. Returns raw token units (divide by 10^decimals); non-standard tokens may return empty name/symbol. Optional fields the response could not confirm are listed in warnings; a field that is missing or false for that reason is unknown for this response, not a confirmed answer.

Query ERC20 Transfer(from, to, value) event logs via eth_getLogs directly from the node. Filter by token contract and/or wallet address. Block params accept decimal, hex, or named tags ("latest", "pending", etc.). Returns decoded transfer events with sender, recipient, and value, plus the from_block/to_block actually queried. Omitting from_block/to_block queries ONLY the latest block — a single block, not a recent window. Size ranges by TIME, not by a fixed block count: block time varies from ~12s (ethereum) to ~100ms (robinhood and other L2s), so 10 blocks is two minutes on one chain and one second on another. Call 1s_network_info first and use avg_block_time_ms to convert the window you want into blocks. A count of 0 usually means the range was too narrow rather than that no transfers occurred — check the returned from_block/to_block before reporting a token as inactive. A busy token can exceed the response limit in far fewer blocks than expected. When that happens the result is still usable: you get the first whole blocks of the range plus "truncated": true, "returned", "total" and "next_from_block". Call again with from_block=next_from_block to continue — pages are cut on block boundaries, so this skips nothing and repeats nothing. Page through rather than retrying the same window smaller, which pays twice for overlapping data.

Enumerate ERC721 tokens owned by an address via ERC721Enumerable. Only works for contracts that implement the Enumerable extension. Returns token IDs owned by the address. If warnings lists the token collection, the returned tokens are an incomplete set, not the full holdings for that address.

Estimate gas required for a transaction via eth_estimateGas. Use this before sending transactions to set appropriate gas limits. Returns the estimated gas as a hex value; reverts return the revert reason.

Query raw event logs via eth_getLogs directly from the node. Filter by contract address and/or topic0 (keccak256 hash of event signature, e.g. Transfer(address,address,uint256)). Block params accept decimal, hex, or named tags ("latest", "pending", etc.). Returns raw log entries with topics, data, and block context, plus the from_block/to_block actually queried. Always specify a contract address when possible. Omitting from_block/to_block queries ONLY the latest block — a single block, not a recent window. Size ranges by TIME, not by a fixed block count: block time varies from ~12s (ethereum) to ~100ms (robinhood and other L2s), so 10 blocks is two minutes on one chain and one second on another. Call 1s_network_info first and use avg_block_time_ms to convert the window you want into blocks. A count of 0 usually means the range was too narrow rather than that nothing happened — check the returned from_block/to_block before concluding a contract is idle. A busy contract can exceed the response limit in far fewer blocks than expected. When that happens the result is still usable: you get the first whole blocks of the range plus "truncated": true, "returned", "total" and "next_from_block". Call again with from_block=next_from_block to continue — pages are cut on block boundaries, so this skips nothing and repeats nothing. Page through rather than retrying the same window smaller, which pays twice for overlapping data.

High-level summary of the OneSource REST API: how many operations it exposes, the tags they are grouped under, the networks it routes, the payment protocols it accepts, and a handful of sample endpoints. Start here when you do not yet know what the API covers. Free, no authentication required.

How to authenticate to the OneSource REST API — an API key from a subscription, x402 (USDC on Base), or MPP (USDC.e or pathUSD on Tempo) — and how to choose between them. This covers calling the REST API directly; to configure this MCP server, call 1s_setup_check. Free, no authentication required.

Full reference for a single OneSource REST API endpoint: parameters, request body, example response, price, use cases, and a ready-to-run curl command. Accepts an operation ID or a path. Use 1s_list_endpoints or 1s_search_use_cases first if you do not know which endpoint you need. Free, no authentication required.

Pricing and payment protocols for the OneSource REST API — which rails it accepts, the price range per call, and the recipient address. Pass an endpoint for that endpoint's specific price. This describes what the API charges; 1s_batch_config changes what this server pays with. Free, no authentication required.

List OneSource REST API endpoints with their method, path, per-call price, and a one-line summary. Pass a tag to narrow the list to one area of the API. Free, no authentication required.

List the networks the OneSource REST API can route to, as declared by its published specification, and how to select one on a call. This is the documented roster; 1s_network_info queries a chain live. Free, no authentication required.

Get native ETH plus balances for up to 20 caller-supplied ERC20 contract addresses in one bounded RPC batch. Tokens are queried, not discovered, and the tool does not calculate a portfolio value. Individual token errors are returned per-token without failing the entire request; exceeding the 20-token cap rejects the request. Optional fields the response could not confirm are listed in warnings; a field that is missing or false for that reason is unknown for this response, not a confirmed answer.

Get network information and chain characteristics in one call: chain ID, latest block number, gas price, how far behind the chain head is, and what kind of chain this is. Returns hex-encoded values; gas price is in wei. CALL THIS FIRST when working with an unfamiliar network — it is the only way to learn the properties that make other results interpretable. The "chain" object reports layer, stack, settles_to, avg_block_time_ms, native_currency, and whether ens, a public mempool, and indexed history are available. Use avg_block_time_ms to size block ranges: cadence spans ~12s (ethereum) to ~100ms (L2s), so a fixed block count means very different windows per chain. Check "stale" before trusting ANY latest-relative read: it reports whether head_age_seconds exceeds this network's stale_after_seconds threshold. A frozen chain client and a genuinely idle chain return identical-looking data, and stale is the only signal that distinguishes them — if it is true, treat block numbers, balances and logs as a snapshot from head_age_seconds ago, not as current. Historical reads remain correct when a head is stale. On layer-2 networks gas_price is the L2 base fee only and gas_price_note explains why: the L1 data cost is charged as additional gas units, so use 1s_estimate_gas for a total cost basis rather than multiplying gas_price yourself.

Fetch NFT metadata directly from the blockchain via tokenURI/uri RPC call. Resolves all URI formats: ipfs://, ar://, data: URIs, bare CIDs, and ERC1155 {id} templates.

Get the current NFT owner via ownerOf(tokenId) RPC call. Only works for ERC721 tokens.

Get the transaction count (nonce) for an address via eth_getTransactionCount. Use this to set the correct nonce when constructing transactions. Returns the count as a hex value.

View or switch how this session pays for metered calls. Two rails, each with two modes: x402-exact (per-call USDC on Base, default), x402-batch (Base payment channel — one deposit funds many off-chain calls), mpp-charge (per-call on Tempo, USDC.e/pathUSD), and mpp-session (Tempo voucher channel). Channel modes are cheaper for a burst of calls but lock a deposit until the channel is closed/refunded. Each rail uses its own wallet (X402_PRIVATE_KEY on Base / MPP_PRIVATE_KEY on Tempo). Call with no arguments to see the current mode and which modes are available. Only applies when paying via a wallet; with an API key, calls are covered by your plan.

Get the current pending block via eth_getBlockByNumber("pending"). On networks with a public mempool (ethereum, sepolia) this shows transactions waiting for inclusion, and the response can be very large (1MB+) on mainnet. On single-sequencer chains it is NOT a mempool view: robinhood and other L2s order transactions first-come-first-served with no public pending pool, so the call still succeeds but returns essentially the next block rather than a queue. An empty or near-empty result there means "not applicable on this chain", NOT "no activity" and NOT "no front-running risk" — check the mempool field from 1s_network_info before drawing either conclusion. Prefer 1s_network_info for chain status or 1s_tx_details_live for specific transactions.

Detect if a contract is a proxy and read its implementation address. Checks EIP-1967 (transparent/UUPS/beacon) storage slots. Returns the proxy type, implementation address, and admin if applicable. Optional fields the response could not confirm are listed in warnings; a field that is missing or false for that reason is unknown for this response, not a confirmed answer.

Reclaim the unused deposit from an open payment channel back to your wallet right away, instead of waiting for the channel to be closed or auto-refunded. Channel modes deposit funds up front to cover many calls; whatever you do not spend stays locked until reclaimed. Works for whichever channel is active this session: x402 batch (USDC on Base) or MPP session (USDC.e/pathUSD on Tempo). Call this when you are done making channel-mode calls. Not needed for per-call modes (x402-exact / mpp-charge) or API-key auth — there is no channel deposit to reclaim.

Report a bug or issue to the OneSource team. Use when a tool returns an unexpected error or when the user asks to report a problem. Free, no payment required.

Search the OneSource developer documentation by keyword and return the best-matching sections. Use this for conceptual questions — getting started, guides, concepts, how-tos. For the parameters and response of one specific endpoint, use 1s_get_endpoint_reference instead. Free, no authentication required.

Find the OneSource REST API endpoints that fit a task described in plain language (for example "check who owns an NFT" or "decode a transaction"). Use this when you know what you want to do but not which endpoint does it. Free, no authentication required.

Interactive setup & health check for the OneSource MCP server. Returns a step-by-step setup script that the AGENT must run by consulting the user: it walks through EVERY configuration choice for BOTH payment rails (auth method, API key, x402 on Base, MPP on Tempo, payment modes, channel preferences) one decision at a time, every time it is run — even when everything is already configured, so the user can review and adjust without touching env vars or config files directly. Also reports version, auth status, channel status, and connectivity. Free, no authentication required. Call this first to set up, to change configuration, or to troubleshoot.

Simulate a contract call via eth_call without sending a transaction. Use this to preview call results, decode return data, or check for reverts before sending. Returns the raw hex result or revert reason.

Get the verified registry of The Standard Reserve (TSR) contracts and pool on Robinhood Chain: token, Charter NFT, Central Bank, tax hook, vaults, auctions, genesis minter, registry, and pool, each with a verification status. Check an address here before sending funds; more than 100 lookalike contracts exist. Always answers, even before every address is fully verified: check registry_status (placeholder|partial|verified) and each row's own verification_status before trusting an address. Free, no payment required.

List per-day history for The Standard Reserve (TSR)'s license or charter auction on Robinhood Chain, newest day first: open/floor/close price, offered vs. sold, first/last sale time, sold-out time, and minutes to sell out. Requires kind (license or charter). Page with before (a day number, exclusive) and limit. Fields ending in _raw are 18-decimal integers as strings.

List recent sales for The Standard Reserve (TSR)'s license or charter auction on Robinhood Chain, newest first: buyer, unit price, count, and block. Filter by kind (license or charter, both returned when omitted), optionally narrow to charter_id, and page with before (a "block:log_index" cursor from a prior page) and limit. Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.

Get The Standard Reserve (TSR)'s current Dutch-auction quotes on Robinhood Chain for the daily STANDARD license auction and the ETH charter auction: price now (when the formula allows it), floor, last sale, daily license supply, and expected license prices at short wait horizons. Each side also reports units_offered/units_sold/units_remaining, sold_out, and phase (not_started, live, sold_out, paused, or unknown). When sold_out is true, price_now_raw is still the decay curve's value, not a live price you can actually buy at; check sold_out (and price_now_note) before trading on it. A side with price_available false still returns its floor and last sale. Each side also carries a day_clock object (current_day, day_started_at, next_day_starts_at, seconds_to_next_day) telling you when today's auction day rolls into the next one, null with day_clock_reason before that side's auction has started. For fills, call 1s_std_auction_sales filtered by kind. Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.

Get The Standard Reserve (TSR)'s reserve backing on Robinhood Chain: vault ETH balances, discovered reserve-asset holdings (unpriced today — no price source exists yet, so each comes back with eth_value null and valuation "unpriced"), and eth_backing_per_standard (vault ETH per circulating STANDARD) in two variants — excluding_pol is the conservative figure, including_pol folds protocol-owned liquidity back in. Neither variant includes ETH held by the tax hook or fee splitter (see hook_eth_balance_raw/fee_splitter_eth_balance_raw on 1s_std_buyback_readiness) — that ETH is tax collected on trades awaiting a forwardTaxes() call, not vault-held backing. Pass history_hours to get the backing-ratio history instead of the current snapshot, or atBlock to get the backing snapshot at or before that block (ignored when history_hours is set). Fields ending in _raw are 18-decimal integers as strings; divide by 1e18 to get token amounts.

Get the raw, head-fresh state of The Standard Reserve (TSR) Branch license auction on Robinhood Chain: phase (not_started/live/paused, or unknown when the contract did not answer), current/floor/day-start price, half-life, licenses issued per day, today's sold/remaining counts, and sales in the last 5, 15, and 60 minutes. Read straight from the chain (not the indexed pipeline), refreshed every few seconds. A field the contract view did not return comes back null, not zero. day_clock gives the next auction-day boundary (next_day_starts_at, seconds_to_next_day), null with day_clock_reason before the auction has started. For the buy-now-vs-wait decision, use 1s_std_branches_doi instead.

Get The Standard Reserve (TSR) Branch license auction's Days of Issuance (DOI): how many days of new-Branch issuance the current price is worth, a dilution-adjusted DOI if all remaining licenses sell, price over floor, recent sales, and a buy-now-vs-wait table at +15m/+30m/+1h/+4h, all read live from Robinhood Chain (not the indexed pipeline). Prices are exact integer strings; the wait figures are current-pace estimates, not predictions, and assume issuance and Branch count stay constant. Any field the contract could not be read for comes back null, including doi.days when issuance per Branch is zero; null never stands in for zero. day_clock gives the next auction-day boundary (next_day_starts_at, seconds_to_next_day), null with day_clock_reason before the auction has started.

Get a summary across all of The Standard Reserve (TSR)'s active Branches on Robinhood Chain: total active Branches, issuance per Branch per day, and the license price expressed in days of Branch issuance. Issuance per Branch per day reads from a live chain-read estimate before the current epoch settles on-chain, and from the settled total after; `yield_issuance_source` says which one you got. Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.