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.

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

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.

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.

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 total supply of an ERC20 or ERC721 token via totalSupply() RPC call. Use this for real-time supply data. Returns raw token units for ERC20 (divide by 10^decimals) or total count for ERC721. 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 full transaction data and receipt directly from the RPC node. Returns both transaction fields and receipt (status, gas used, logs).

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.

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.

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.

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.

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.

无需输入参数。

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.

Read a raw storage slot from a contract via eth_getStorageAt. Use this for low-level state inspection (e.g. reading proxy implementation slots, packed storage). Slot accepts decimal (e.g. "0") or hex (e.g. "0x0").

Get a transaction receipt via RPC. Returns status (1=success, 0=revert), gas used, logs, and contract address if deployment. Use 1s_tx_details_live for both transaction data and receipt together.

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.

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.

无需输入参数。

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.

无需输入参数。

Get The Standard Reserve (TSR)'s contraction-vault buyback-tick readiness on Robinhood Chain: this tick's ETH capacity (the smaller of the vault's own share and the pool's per-tick cap, with binding_constraint naming which one binds), cooldown time remaining, the current pool tick vs. its TWAP (time-weighted average price) and whether it is within the allowed deviation, whether buyback ticks are open to the public yet, who can run one before that (executor) and who can pause the contract (guardian), ETH sitting in the tax hook and fee splitter awaiting routing, the current policy regime, and recent executed ticks. Fields ending in _raw are 18-decimal integers as strings; divide by 1e18 to get ETH amounts.

Get OHLC price candles for The Standard Reserve (TSR)'s ETH/STANDARD Uniswap v4 pool on Robinhood Chain, priced in ETH per STANDARD, with per-candle swap counts and volume in both tokens. Pass quote="usd" to add open_usd/high_usd/low_usd/close_usd to every candle, derived from Chainlink's ETH/USD feed and treated as an approximation rather than a true historical USD candle; every *_usd field comes back null when that feed reading is stale. Pick a timeframe with tf (1m to 1d, default 1h) and optionally bound the window with from/to (RFC 3339); without them the API returns the most recent 300 candles. Empty buckets are omitted.

Get one The Standard Reserve (TSR) charter by id on Robinhood Chain: holder, branch count, mint kind (genesis or auction), owed production, and branch history. When id is omitted, list charters instead (optionally filtered by owner), newest charter_id first by default. The list is keyset-paginated: pass the previous response's next_before back as `before` (or next_after back as `after` with order "asc") to fetch the next page; total_charters in the response says how many charters match the filter overall. A charter is a soulbound bank-charter NFT that holds 1 to 10 Branches. Call 1s_std_branches_summary first to find a charter id. The response also has a `stimulus` object for the one-time charter stimulus: STANDARD already claimed and still claimable on this charter. The claim deadline is in the `deadline` field of the stimulus object. The charter's current owner claims it. Charter transfers are disabled on chain today, so that is the wallet holding the charter. A full exit forfeits an unclaimed stimulus (confirmed by simulation). On a burned charter, `forfeited_raw` is the amount it lost. With an id, charter_drops gives this charter's share of each launchpad charter drop. Closing branches below the count frozen at a drop makes shares claimable, and the owner claims each drop separately. Each drop has a mode that says when it pays: per_branch as each branch closes, at_exit only once the charter has no branches left. A charter burned by closing its last branch can only claim if noteOwner was called first on each drop contract it has shares in. owner_note.contracts_to_note lists any still missing. Values come in launch tokens, then the pair stock at the pool's spot price, then ETH when the Reserve prices the stock. With an id, a charter revoked for dormancy whose holder has a refund also carries `burned_charter_claim`: the Burned Charter Claim allocation, claimable now, claimed or not, and the deadline. The refund belongs to the wallet that held the charter when it wa

One call with the inputs for thinking about a standing bid on the Branch license auction of The Standard Reserve (TSR), on Robinhood Chain, at a max unit price. Returns when the price reaches that max (derived, today or on the next auction day, with the stated assumption), how many other bids and licenses would be filled before it and the supply left after them (derived), and, with charter_id, that charter's measured pending STANDARD, window and branch caps and any existing bid a new one would replace. Also states how fills happen and the measured fill history: fill() is a separate transaction that anyone may send, so a price crossing is not a fill. Each part comes back under parts.<name> with its own status (ok, not_ready, or error). Requires max_unit_price. It returns inputs only and does not recommend an action.

One call for "should I buy a The Standard Reserve (TSR) Branch or license right now" on Robinhood Chain. Bundles Days of Issuance (1s_std_branches_doi), the ETH cost of a license via the pool vs. the charter-auction path (1s_std_license_cost, with cheapest_path), recent license-auction day history, the policy outlook, and any pending governance change affecting licenses/day or issuance -- plus per-charter license headroom when charterId is given. Each part comes back under parts.<name> with its own status (ok, not_ready, or error); one part failing never fails the whole call. summary carries the handful of numbers a buyer looks at first, including next_day_starts_at and seconds_to_next_day for when the current auction day rolls over. parts.charter_drops_history is history, not a forecast: what one branch counted in each past launchpad charter drop would be worth today. A branch opened now counts toward future drops only.

One call for "should I buy into a new The Standard Reserve (TSR) charter right now" on Robinhood Chain. Bundles the charter-auction state (1s_std_auctions_current, recent charter-auction days), the license-cost route's cheapest_path (does a license or a whole charter buy the cheaper path to operating a branch right now), Days of Issuance, ETH backing per STANDARD, holder concentration and the genesis-vs-auction cohort split, and any pending governance change affecting charters/day. Each part comes back under parts.<name> with its own status (ok, not_ready, or error); one part failing never fails the whole call. The charter-auction state includes charter.expected_prices: the price path for the rest of the current auction day at +15m, +30m, +1h, +4h and end of day, derived from the measured price and the charter's own half-life (derived; assumes no purchase before then and no parameter changes; rows that would land in the next day are null with a reason). parts.charter_drops_history is history, not a forecast: what one branch counted in each past launchpad charter drop would be worth today. A branch opened now counts toward future drops only.

无需输入参数。

One call for "should I exit this The Standard Reserve (TSR) charter's branches right now" on Robinhood Chain. Bundles the exit quote (1s_std_exit_quote: gross, fee, net, realizable_eth), the fee curve priced at that same quote's gross, the fee forecast (days until the fee returns to its floor if no further exits happen), the current buy/sell tax schedule, the live pool state, the policy outlook, and any pending governance change affecting fees, resolution, exit or pressure. parts.sbills_alternative quotes the exit's net STANDARD (after the exit fee) as an S-Bills deposit: rate paid for one term, premium, term length, and the exit fee that bill would pay. It is derived, assumes staking immediately with no other deposits, and is read live at the chain head. parts.stimulus and the summary.stimulus_* fields show the charter's unclaimed stimulus. A full exit burns the charter and forfeits it (confirmed by simulation); a partial exit does not. The claim deadline is in the `deadline` field. Charter transfers are disabled on chain today, so only the wallet holding the charter can claim. Each part comes back under parts.<name> with its own status (ok, not_ready, or error); one part failing never fails the whole call. Requires charterId. If branches is omitted, it defaults to the charter's current branch count (or 1 if that isn't known yet) rather than being left out of the exit quote entirely; the response echoes summary.branches_used and summary.branches_source (query, charter_count, or default) so you can see which one was used. Call 1s_std_charter first to see how many branches are open if you want to pass a specific number. parts.charter_drops shows what closing these branches releases from launchpad charter drops (claimed separately, one claim per drop) and what is already claimable. An at_exit drop releases its share only when the close takes the charter to zero branches. It warns to call noteOwner before closing the last branch, and names each drop contract to call it

One call with the inputs for holding STANDARD on The Standard Reserve (TSR) on Robinhood Chain. Returns the policy outlook, issuance runway, pending governance changes, tax schedule, buyback readiness and dormancy state. summary is a flat map of the headline numbers. Each part comes back under parts.<name> with its own status (ok, not_ready, or error); one part failing never fails the whole call. Dormancy carries the reportable wallet count, not the full list; the count is null until the dormancy window has been read from chain. It returns inputs only and does not recommend an action. Takes no arguments.

无需输入参数。

Simulate three Branch-expansion strategies for a Standard Reserve (TSR) charter on Robinhood Chain: keep (never buys a license), selective (buys one license every selective_interval_days, budget permitting), and aggressive (buys up to the daily license-auction cap every day, budget permitting). Every input can be seeded live from this API's own routes (current license price, pool spot price, issuance rate, branch counts) or overridden explicitly; the response reports which source each one came from (seeded_live, user_supplied, or default) under assumptions. By default (license_funding=eth) every license is paid for in wallet STANDARD bought with ETH, matching how LicenseAuction actually charges a purchase (burnFrom the wallet -- there is no contract path that pays with pending credits directly); license_funding=credits instead withdraws accrued credits first, paying the live resolution fee on each withdrawal. Unless resolution_fee_wad is supplied, the terminal exit fee is recomputed in both funding modes from that same live curve, whose trailing withdrawal window rolls forward a day at a time over feeWindowDays so an old withdrawal ages out instead of counting against the fee for the rest of the horizon. At the end of the horizon, remaining credits are released according to exit_mode (all, one, or none), the terminal resolution fee is applied, and the resulting STANDARD is sold at the simulated terminal price with sale tax, sale fee, and pool slippage haircuts. Each strategy also carries stake_instead_of_sale: the same net STANDARD priced as an S-Bills (fixed-term STANDARD staking) deposit at the end of the horizon instead of sold, with the contract's quote today (measured) and a projected rate and premium at that later moment (derived, as the only deposit, no parameter changes). It sits beside the sale and ranks neither. This is a simulation for exploring tradeoffs, not a forecast or a recommendation: the response never names a winning strategy. With charterId, cha

One call with the figures for a single S-Bill on The Standard Reserve (TSR), on Robinhood Chain: the bill's record, the live S-Bills state, and a block that depends on the bill's state. An active bill gets the exact payout of an exit now (measured), the premium an early exit gives up, and the exit fee for each coming day until the fee stops changing or the bill matures (derived; the response states its assumption). A matured bill gets the redeem payout (measured) and what rolling it would lock (derived), and notes that nothing rolls automatically, so a matured bill earns nothing more until its owner redeems or rolls it. Exited and redeemed bills return the record only. Each part comes back under parts.<name> with its own status (ok, not_ready, or error). An unknown bill id returns 404. Requires bill_id. It returns inputs only and does not recommend an action.

One call with the inputs for staking STANDARD into an S-Bill on The Standard Reserve (TSR), on Robinhood Chain. Returns the rate a deposit of this size would lock now, the premium, the caps checked against the wallet, the exit fee if you left right after depositing, and how the rate would move over 1h, 6h and 24h if nobody else deposits. That projection is derived, and the response states its assumption; the current rate, drift and ceiling it starts from are measured from the contract. The term length comes from the chain. Each part comes back under parts.<name> with its own status (ok, not_ready, or error); one part failing never fails the whole call. Requires amount. It returns inputs only and does not recommend an action.

List The Standard Reserve (TSR) wallets on Robinhood Chain that are already past their reportable dormancy window, ranked by estimated bounty descending: min(bank_bounty_pct_wad/1e18 * owed, bank_bounty_cap) -- bank_bounty_cap is the LIVE cap the CentralBank enforces, which the response also surfaces separately as cap_ceiling_raw (the governance ceiling that live cap can be raised to, not itself a payout limit). owed is each wallet's last-indexed pending-production checkpoint, not a live re-read, so treat bounty_estimate_raw as an estimate, not a guaranteed payout. reportable_at_block is also an estimate: it was computed from an assumed block time, so it can be off by roughly a day's worth of blocks -- a reportDormant() call near the threshold may still revert as not-yet-reportable. The response may carry constants_missing:true if the bounty-percentage or cap constant hasn't been read on-chain yet, in which case wallets is empty. Fields ending in _raw are 18-decimal integers as strings.

List The Standard Reserve (TSR) wallets on Robinhood Chain that are past their reportable dormancy window and eligible for the dormancy bounty, newest first, with their last activity. Set reportable=false to list every tracked wallet's last-activity record instead. The response may carry constants_missing:true if the dormancy-window constant hasn't been read on-chain yet, in which case reportable_at_block is null for every row.

List The Standard Reserve (TSR) epoch history on Robinhood Chain: net flow, signal, regime, multiplier, and issuance per epoch. eth_in_raw/eth_out_raw and taxes_eth_buy_raw/taxes_eth_sell_raw currently come back null — pool-side flow and per-side hook attribution are not wired, so nothing is served rather than a wrong figure. taxes_hook_raw is the measured total ETH tax for the whole hook window. Use this to line up policy changes or auctions with the epoch they happened in. Paginate with before (an epoch number, exclusive) and limit.

List raw decoded The Standard Reserve (TSR) protocol events on Robinhood Chain, newest first. Filter by contract_label, event_name, tx_hash, block_number, log_index, from_address, to_address, owner, token_id, or epoch, and paginate with before (a "block_number:log_index" cursor, exclusive) and limit. Use this for an audit trail of what happened; use the other 1s_std_* tools for current or aggregated state.

See how The Standard Reserve (TSR)'s exit fee changes with the size of a withdrawal, on Robinhood Chain. Returns the current system-wide fee rate plus a ladder at 1%, 5%, 10%, 25%, 50%, and 100% of a gross withdrawal amount, each checked two ways: a live read of the reserve contract's own fee preview, and this tool's own formula computed from the same tracked numbers, so you can see if they agree. In the formula, gross counts only toward the withdrawals in the numerator, not the divisor. Pass gross (in whole STANDARD tokens, not wei) to size the ladder around a specific withdrawal; omit it to use the reserve's entire pending balance. Fields ending in _raw are 18-decimal integers as strings; fields ending in _wad are also 18-decimal integers (the fee's own fixed-point convention). The live fee fields (fee_rate_now_live_wad, and each ladder point's fee_rate_live_wad) are a direct contract read and are always returned. The formula fields (fee_rate_now_formula_wad, fee_rate_formula_wad) are a cross-check and come back null if the fee formula hasn't been validated live yet; check formula_version.

Project how The Standard Reserve (TSR)'s system-wide exit fee would move if no more withdrawals happened, on Robinhood Chain. Rolls the recent withdrawal window forward day by day and reports the fee rate for each future day, plus days_until_min_fee: how many days until the fee would reach its floor under that assumption. expiry_schedule lists the exact instant each recorded withdrawal day leaves the trailing fee window (from the reserve's own day clock, not event timestamps) with the window total and fee after each one; next_fee_change_at is the first expiry that moves the fee. When incomplete_days is non-empty the schedule fields are null and only the day-by-day projection is available. This is a current-pace projection, not a prediction; the response always states its assumptions plainly. Fields ending in _raw are 18-decimal integers as strings; fields ending in _wad are also 18-decimal integers (the fee's own fixed-point convention). fee_rate_now_wad ("today") prefers a direct contract read over the formula's own value, and fee_rate_now_basis says which one it is; the rest of the day-by-day projection, and the schedule fields, are a formula rollforward that comes back null if the fee formula hasn't been validated live yet; check formula_version.

无需输入参数。

Get The Standard Reserve (TSR)'s exit-pressure reading on Robinhood Chain and the resolution (exit) fee rate it produces. Exit pressure is the last 7 days of withdrawals divided by the reserve's total pending balance plus those withdrawals (the divisor has a minimum floor), scaled by a saturation level and capped at 1. The fee runs from 2% to 60% and grows with the square of that pressure. It is not a queue of pending redemptions; read it against the active policy (call 1s_std_policy_current for that context). Pass history_hours to get the history series instead of the latest snapshot (history rows that carry a formula fee report formula: "unknown", because the table does not record which formula version produced them), or atBlock to get the raw snapshot at or before that block (ignored when history_hours is set; the live fee-rate recompute only runs for the current row, not a historical one). Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts. exit_pressure_now_raw is the exact value. exit_pressure_now is the same number as a float, kept for older clients.

Get a pro-rata exit quote for retiring a number of a The Standard Reserve (TSR) charter's open Branches on Robinhood Chain: the gross share of owed production, the exit fee (read directly from the reserve contract for this exact amount, half burned, half redistributed), the net STANDARD to the wallet, and realizable_eth, an estimate of the ETH you'd actually get for selling that net STANDARD into the live pool, accounting for price impact and the sell tax. Requires charterId and branches (the number of open Branches to exit). Call 1s_std_charter first to see how many branches are open. Pass atBlock to price realizable_eth against a historical pool state instead of the latest one (the pending amount itself is always current). Fields ending in _raw are 18-decimal integers as strings; fields ending in _wad are also 18-decimal integers (the fee's own fixed-point convention). estimate:true and assumptions[] mark every response.

Get The Standard Reserve (TSR) ETH/STANDARD pool buys and sells grouped by wallets that held at least one Charter at the exact block and log position of each swap. Current ownership is not applied retroactively, each swap is counted once even when its wallet held multiple Charters, and ambiguous multi-swap transactions are excluded rather than assigned to a guessed wallet. Filter with hours and limit. Fields ending in _raw are integer base-unit amounts returned as strings.

Get The Standard Reserve (TSR)'s hourly ETH flow into and out of the ETH/STANDARD pool on Robinhood Chain, with swap counts and net flow per hour. Filter with hours (how many hours of history to return); the most recent hour may still be open and update as new swaps arrive. Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.

Get head-fresh stats on The Standard Reserve (TSR)'s genesis Dutch mint on Robinhood Chain: phase (allowlist/public/ended/finalized), total minted, remaining, current public price, sold in the last 30s/1m/5m, velocity, and a pace-implied sellout time and price. The sellout figure is a current-pace estimate, not a prediction. Read straight from the chain, refreshed every few seconds. Free.

无需输入参数。

Get The Standard Reserve (TSR)'s governance history on Robinhood Chain: every param-change event across its 12 contracts (queued, applied, set, paused, unpaused, locked), newest first, plus what is currently queued but not yet applied, the state of the one-way/gated switches (transfers_enabled, launch_holding_cap_active, pool_manager_gate_enabled, launch_schedule_active), each contract's latest guardian pause state, and the address registry's own state (whether buyback ticks and POL pairing are open to the public, which periphery bindings are permanently locked, and the current executor/guardian/net flow source/genesis minter/owner addresses). Pass contract to filter to one contract_label. Values are decoded to a fraction when the param name makes the unit unambiguous (bps or wad); otherwise unit is "raw".

See how concentrated The Standard Reserve (TSR) Charter/Branch ownership is on Robinhood Chain: the distribution of open Branches per Charter, the top owners by Branches held and their share, a Herfindahl-Hirschman Index (HHI, a standard 0-10000 ownership-concentration score: higher means fewer wallets hold more of the total) of that ownership, and a genesis-vs-auction cohort split with retirement/revocation counts. Ownership figures cover live (not burned) Charters only; the cohort split covers every Charter, live and burned. concentration_hhi comes back null (not zero) when there are no live Branches to distribute.

Get The Standard Reserve (TSR)'s issuance runway on Robinhood Chain: cumulative STANDARD issued so far against the Central Bank's issuance budget, the current per-second stream rate, budget remaining, and a same-state projection of when the budget runs out if that rate holds (`projected_end_at_current_multiplier`). `issuance_end_raw` is the contract's own measured end timestamp and is the authoritative figure; the projection can diverge from it once the policy multiplier changes, see 1s_std_policy_outlook. Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.

无需输入参数。

Which Uniswap v4 pools does this launchpad token's venue policy forbid? Get one launchpad v2 token's URC-5 (Token Venue Policy) record on Robinhood Chain: its live mode (enforced or preferred), its official ("canonical") pools, and every Uniswap v4 pool that holds it. Each pool is marked canonical or off_list, with allowed_by_policy and in-range liquidity (the liquidity active at the current price, not total deposits). Enforced means routers that follow URC-5 must not use other v4 pools. Preferred means official pools are recommended and others are allowed. Before graduation a token lists no official pool, so an enforced token allows no v4 pool yet. launch.creator_venue_choice is what the creator picked at launch. It is not the live mode. Also returns policy history and a summary. An unknown token, including launchpad v1 launches and STANDARD itself, returns 404. If the data is too old the route answers 503 withheld instead of guessing. Values are the last snapshot reads at the block numbers shown, not live reads.

Is this Uniswap v4 pool the token's official pool, and is it allowed? Chain-wide URC-5 (Token Venue Policy) view of launchpad v2 tokens on Robinhood Chain: counts of tokens by mode (enforced or preferred), pools, canonical and off-list pools, and off-list pools the token's policy does not allow, including how many of those hold liquidity. The list shows only off-list pools that are not allowed by default. Set scope=all for every pool, and page with before (the next_before cursor) and limit. Pass pool_id to look up one pool: pool_lookup answers per token, plus one overall answer that is the most restrictive of them. A pool can hold two launchpad tokens and is judged by each token's own policy. Before graduation a token lists no official pool, so v4 pools holding an ungraduated enforced token are off-list and not allowed. A row whose reads are too old is flagged stale, has no classification, and is counted as withheld. If even the newest read is too old the route answers 503 withheld. For one token's full record use 1s_std_launchpad_token. Values are the last snapshot reads, not live reads.

List every standing bid on the Branch license auction of The Standard Reserve (TSR), on Robinhood Chain, read at one block. A bid is a standing order on a charter: a count (1 to 3) and a maximum unit price. Nothing is escrowed; a fill is paid from the charter's pending STANDARD, and fill() is a separate transaction that anyone may send. Each bid carries the contract's own fillable answer, the checks behind it, and a blocking list naming every failing check (price above max, daily supply used up, charter window or branch cap, insufficient pending, owner changed, charter burned). Stale bids are flagged and prunable. effective_crossing_price_raw is derived, and the response states its assumption. Bidder addresses are public chain state and are included. Optional charter_id, bidder, fillable_only and sort (max_desc or charter_id). Fields ending in _raw are 18-decimal integers as strings. It returns facts only and does not recommend an action.

Get what a Branch license actually costs in ETH right now for The Standard Reserve (TSR) on Robinhood Chain, and whether the charter auction is a cheaper path to the same outcome. Converts the current STANDARD-denominated license price to an estimated ETH cost via the STANDARD/ETH pool (a single-range price-impact estimate, plus the current buy tax, and the pool's own LP fee — pool_lp_fee_ppm, converted to lp_fee_bps — taken after the buy tax from the ETH going into the swap), compares it against the charter auction's own ETH price when that auction is live, and names the cheaper path in cheapest_path ("license", "charter", or "n/a"). Also expresses the license price in branch-days of issuance. This is an estimate (see assumptions), not a substitute for a live quote from the contracts. Fields ending in _raw are 18-decimal integers as strings.

无需输入参数。

Get how many more Branch licenses a The Standard Reserve (TSR) charter can still buy today on Robinhood Chain, read live from the License Auction contract (currentDay, purchasedOnDay), compared against the per-charter daily cap. Includes a live quote(n) ladder for buying 1 up to the remaining count (capped at 3), each returning the contract's own unit price and running total. The charter is verified to exist first: an unknown charterId returns a 404, and a burned charter returns a 409 instead of a quote. Requires charterId. Fields ending in _raw are 18-decimal integers as strings.

Get The Standard Reserve (TSR)'s current monetary policy on Robinhood Chain: the current epoch number, regime (expansion or contraction), policy multiplier, net ETH flow, and the two-epoch signal, with time to the epoch boundary when known. Call this before interpreting exit-pressure or supply figures, since both are read against the active policy. Pass atBlock to get the epoch that was current at or before that block instead of the live one (time_to_close_seconds is omitted for a historical epoch). Regime, multiplier, issuance and net flow are only finalized once the current epoch settles on-chain; before that, this returns a live chain-read estimate instead of null, each tagged with a `_source` and `_basis`/`_note` field so you can tell a settled value from a provisional one (`regime_provisional` in particular is a sign-based guess, not what the contract itself reports). Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.

Get The Standard Reserve (TSR)'s current-sign-holds outlook on Robinhood Chain: what the Central Bank's policy multiplier and issuance rate would be if the current epoch's net ETH flow sign holds all the way to close. This is a same-state projection, not a forecast: it changes the moment the underlying flow does, and the response always carries `projection` and `assumptions` naming what is held constant. Call 1s_std_policy_current first for the settled epoch history this projects from. Fields ending in _raw are 18-decimal integers as strings (multiplier and issuance figures are WAD-scaled, i.e. divide by 1e18). A null field means an input hasn't been read on-chain yet rather than a guessed value.

无需输入参数。

Get the latest state of The Standard Reserve (TSR)'s ETH/STANDARD Uniswap v4 pool on Robinhood Chain: price, tick, liquidity, reserves, remaining launch tax, and the pool's own LP fee (lp_fee_bps, converted from the on-chain pool_lp_fee_ppm). Also includes a USD price (price_usd_per_std, eth_usd_raw) derived from Chainlink's ETH/USD feed on Ethereum mainnet, null with usd_unavailable_reason set when that feed reading is missing or over an hour stale. May come back with serving_state=lagging when the indexer is behind; a request answers 503 if the data is too stale to serve at all. Pass atBlock to get the pool state at or before that block instead of the latest one (the serving_state/lag checks only apply to the live path).

List money movements by The Standard Reserve (TSR) protocol on Robinhood Chain, newest first in chain order. Filter with kind: holdings_migrated, taxes_forwarded, fees_recycled, team_claimed, pol_buyback, pol_fees_collected, pol_paired, incentive_sent, or vault_outflow. A pol_paired row is ETH the PolManager added to the pool as protocol-owned liquidity after swapping part of it to STANDARD; eth_amount is the ETH committed. A vault_outflow row is value that left the multisig-held reserve vault, in ETH or an ERC-20 token, with the method that moved it. A batched Safe transaction gets one row per send, told apart by sub_index. Page with limit and cursor: pass next_cursor from the previous response. An unknown kind or a malformed cursor returns an error. eth_amount, std_amount and token_amount are integers as strings. Divide by the token's decimals (1e18 for ETH and STANDARD, 1e6 for USDG) or read the matching *_dec field.

Get one The Standard Reserve (TSR) S-Bill by id, or list S-Bills filtered by owner and/or status, on Robinhood Chain: principal, premium, locked rate, maturity, settlement and how each closed. The single-bill form (pass billId) also returns the bill's full event history and live exit_quote/redeem_quote cross-checks when the bill is still active; the contract quotes a redemption only after maturity, so until then redeem_quote is null and redeem_quote_reason says why. The contract has no automatic roll; the owner must call roll after maturity. The list form is keyset-paginated on bill_id descending; pass the previous response's next_before back as before to fetch the next page. Fields ending in _raw are 18-decimal integers as strings.

Get The Standard Reserve (TSR) S-Bills staking terms right now, on Robinhood Chain: the rate per term and its simple APR at the live term length, drift state, principal locked, premium budget and escrow, caps, pause/close flags, and the early-exit fee window. exit.fee_estimates gives the estimated early-exit fee for four deposit sizes, checked against live quotes. S-Bills are fixed-term STANDARD staking: a deposit locks principal for one term at a per-term rate, with the premium escrowed up front. Rates are per term, not annual; check rate_basis and term_seconds before reading a number as an annual figure. The contract has no automatic roll; the owner must call roll after maturity. Fields ending in _raw are 18-decimal integers as strings; divide by 1e18 to get token amounts.

List decoded The Standard Reserve (TSR) S-Bills contract events on Robinhood Chain, newest first: deposits, early exits, redemptions, rolls, settlements, bonus distributions, rate changes and admin changes. Filter by eventName, bill_id, or owner, and paginate with before (a "block:log_index" cursor, exclusive) and limit. Fields ending in _raw are 18-decimal integers as strings.

Get a live quote for staking N whole STANDARD tokens into a new The Standard Reserve (TSR) S-Bill, on Robinhood Chain: the rate you would lock, the premium escrowed for you, and the rate after your deposit, read straight from the contract rather than from indexed state. Also reports whether caps, minimum deposit, pause, or budget would currently block the deposit, and exit_fee_estimate: an estimate of the early-exit fee if you left right after depositing, checked against live quotes. An early exit returns principal minus that fee; the premium and any stayer bonus are never paid out early. Rates are per term, not annual. amount is whole STANDARD tokens (not wei), as a decimal string. Pass wallet to also check the deposit against that wallet's open principal and its headroom under the per-wallet cap.

See how The Standard Reserve (TSR) S-Bill rate has moved over time, on Robinhood Chain: every on-chain rate change (deposits, admin changes, pause) plus periodic drift samples, each tagged by source and carrying the term length in force at that point, oldest first. term_changes lists every admin term-length change in the window separately. Rates are per term, not annual. Fields ending in _wad are 18-decimal fractions as strings.

Get The Standard Reserve (TSR)'s STANDARD supply ledger on Robinhood Chain: circulating supply, cumulative minted, cumulative burned by path (licenses, buybacks, fees), and max supply. burned_cum_raw counts every token sent to the burn address, including deposit conversions a later withdrawal re-mints; burned_forever_cum_raw is the permanent subset (public burn/burnFrom) and deposited_cum_raw is the re-mintable subset (CentralBank convertFrom), which together should equal burned_cum_raw; ledger_retired_cum_raw is a separate figure — unminted ledger value written off with no token movement (license payments, unrecycled fees) — that lowers max supply the same way a permanent burn does. Pass history_hours to get the supply ledger history instead of the latest row. For a time series of pool flow instead of a supply snapshot, use 1s_std_flow_hourly. Pass atBlock to get the supply ledger row at or before that block instead of the latest one (ignored when history_hours is set). The latest row also carries a `stimulus` object for the one-time charter stimulus: STANDARD funded, claimed, swept and still unclaimed, plus the claim `deadline`. Unclaimed STANDARD is part of circulating supply. The object is null when atBlock is set. Fields ending in _raw are 18-decimal integers as strings. Divide by 1e18 to get token amounts.

Get The Standard Reserve (TSR)'s launch tax-hook schedule on Robinhood Chain: the measured current buy/sell tax in basis points, the decay configuration, floor_reached_at (when the tax reaches its permanent floor), and — only while the launch schedule is active and not overridden by governance — a labeled +5m/+15m/+30m projection computed from the chain's own decay-curve constants. freshness_basis says what the response's freshness is measured against: snapshot_pass_marker is the normal case, stamped only after every hook read this response uses succeeds together in one pass, so a tax rate that stopped changing (post-floor) still reads as fresh rather than stale; constants_read_at is a fallback for when that marker isn't available yet. Projections are estimates, not a guarantee: they assume no governance change before the horizon.

无需输入参数。

Get The Standard Reserve (TSR)'s Expansion and Contraction vault balances on Robinhood Chain: vault ETH, POL manager idle balances, principal ETH/STANDARD deployed in its two direct Uniswap v4 positions, uncollected position fees, total POL-controlled balances, and buyback capacity. Pass history_hours to get the vault snapshot history instead of the latest snapshot, or atBlock to get the 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 one wallet's full The Standard Reserve (TSR) position on Robinhood Chain: every Charter it holds with that Charter's pending owed STANDARD (the last-indexed checkpoint, not a live re-read), a total-owed sum, a summary exit quote (the pro-rata resolution-fee math the exit-quote route itself owns, summed across every Charter's full open-Branch count), the wallet's dormancy record with an estimated time until it becomes reportable for the dormancy bounty, and each Charter's license-purchase headroom for today. Each Charter and the wallet as a whole also carry a `stimulus` object for the one-time charter stimulus: STANDARD claimable now and already claimed. The claim deadline is in the `deadline` field of the stimulus object. The charter's current owner claims it. Charter transfers are disabled on chain today, so that is the wallet holding the charter. A full exit forfeits an unclaimed stimulus (confirmed by simulation). Fields ending in _raw are 18-decimal integers as strings; divide by 1e18 for token amounts. charter_drops rolls the same launchpad drop shares up over every Charter: claimable, still locked (open branches, or an at_exit drop that pays only when the charter has none), and how many Charters should call noteOwner before closing their last branch. Values come in launch tokens, then pair stock, then ETH when priced. When the wallet held a charter that was revoked for dormancy and has a refund, burned_charter_claim shows that allocation: claimable now, claimed or not, the deadline and which charters it covers. It is one amount for the wallet, and only this wallet can claim it. The block is absent otherwise.

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.

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.

无需输入参数。

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.

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.

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.

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.

无需输入参数。

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.

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.

无需输入参数。

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.

无需输入参数。

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.

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.