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 maker rewards earned. The reward token is per-market, not fixed — call 1s_ds_markets and read that market’s `reward_token` (NVDA/USDG has paid 2DEEP since the DGP-3 migration on 2026-09-22; DEEP/USDG is a legacy book and earns no rewards). 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, pool/router addresses, lifecycle `status`, and `reward_token`. `status` is one of `live`, `price_decode_pending`, `legacy` (token superseded, may still have resting orders), or `registered` (exists on-chain, not yet trading). `reward_token` is the token maker rewards pay in for that market — 2DEEP for NVDA/USDG since the DGP-3 migration on 2026-09-22; DEEP/USDG is legacy and pays no rewards. 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.

Track how much of the old DEEP and STATE supply has been redeemed for 2DEEP since the DGP-3 upgrade on 2026-09-22, and how much is still outstanding. Returns the redemption ratio, when the upgrade executed (block and time), DEEP and STATE redeemed totals and counts, 2DEEP minted for STATE redemptions, and what remains redeemable of each, plus a daily series over an optional from/to window. These totals and counts come from an indexed event stream and are a floor, not an exact count: `truncated` is true when the window held more events than one read caps at, and the index is still being backfilled for 2026-09-22/23 while a replay runs, so until that finishes, treat counts as at-least, not exact. Redemption has no deadline; this reports progress so far. Call 1s_ds_token_2deep for the current live totals instead of a point-in-time snapshot.

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 2DEEP’s current supply, supply cap, float, Rewarder V3 balance, endowment locked, and outstanding migration liabilities, read live from chain. 2DEEP replaced DEEP and STATE in the DGP-3 upgrade on 2026-09-22, and every figure here reflects that migration: `state_to_2deep_wad`/`state_to_2deep` (1 STATE redeems for 3.0155 2DEEP; DEEP redeems 1:1), plus `legacy_deep_total_supply_raw`/`legacy_state_total_supply_raw`, the old tokens’ current total supplies (the DEEP figure includes about 793M DEEP stranded forever in the retired Rewarder V1, which can never be redeemed; for what’s actually still redeemable see 1s_ds_migration’s `remaining_deep_redeemable_raw`/`remaining_state_redeemable_raw`). `price_usdg`/`price_usdg_raw` come from the USDG/2DEEP Uniswap v4 pool and are omitted from the response until that pool has a trade; `price_source` still names the pool, so a client can tell "no price yet" from "wrong pool". There is no deadline to redeem old DEEP or STATE.

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. License days also carry purchase aggregates: transaction_count, distinct_charters, average_price_raw, total_paid_raw, and purchase_size_distribution (licenses bought per transaction to number of transactions); these are null for charter days. 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, reserve-asset holdings, the Uniswap v4 positions the expansion vault owns (vault_positions), and eth_backing_per_standard (ETH per circulating STANDARD) in three variants. excluding_pol is vault ETH only, the conservative figure. including_pol adds total POL-controlled ETH (idle + position principal + uncollected fees) and is null when pol_position_basis is position_inventory_unavailable. including_reserve_assets adds the ETH value of vault_positions and of the priced reserve_assets to vault ETH, leaves out POL, and is null until a snapshot has both positions and prices. Part of the vault's ETH was redeployed into USDG and Uniswap v4 pools, so excluding_pol and including_pol fall when that happens. reserve_value splits the reserve-inclusive figure into components (vault_positions_eth, usdg_eth, stock_tokens_eth), a total, and an unpriced list. Stock tokens and positions are valued at the current price in the Reserve's own stock/USDG pools and USDG at $1 via Chainlink ETH/USD, so selling a large amount would fetch less; eth_value and valuation on reserve_assets name the basis, and unpriced assets keep eth_value null. Position STANDARD and per-range POL liquidity are also returned. No 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.