OneSource MCP

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 w…

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 i…

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, ch…

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

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.