OneSource MCP

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.

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.

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.

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

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. This is a simulation for exploring tradeoffs, not a forecast or a recommendation: the response never names a winning strategy.

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) 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) 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. 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). Fee fields come back null if the mainnet 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. 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). Fields come back null if the mainnet 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 reserve's own accumulated exit activity, decayed toward zero over time, 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, 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 (the validated mainnet formula, 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)'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.

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

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). 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: WETH and STANDARD held, protocol-owned liquidity, 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. Fields ending in _raw are 18-decimal integers as strings; divide by 1e18 for token amounts.

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