SUSHI CATE / METHODS & DATA

What this is, and what it is not.

Sushi Cate is a demonstration interface for a narrative-market product: a ranked board of themed baskets, a detail page per basket, a swap panel, and a shared controller working the counter. It is a front end and nothing else. This page documents every number you can see and where it comes from, so that no part of the interface has to be taken on trust. The set returns are real market arithmetic; the counter is an animation; nothing is an offer.

Scope

There is no exchange, no order book, no router, no custody, no settlement and no counterparty on this site. $SUSHICATE is a Solana (SPL) token; the Buy coin control in the header links to a Solana DEX once the mint address is published. No page here can create, sign or broadcast a transaction, and none of them read a wallet. The buttons labelled Trade, Give me trades, Connect wallet and Sign in are deliberately inert and say so when pressed.

Company names appear as the stated composition of a basket. They describe what a basket is about; they do not represent anything anyone holds, and they imply no relationship with or endorsement by those companies. Nothing on this site is investment advice.

What is real: the prices. What is not: everything you could do with them. A set's line is arithmetic over a public price feed, not a fund, an index, a product or a record of any trade.

Return series

Every percentage and every line on the board and set pages is computed from real, delayed market prices. Nothing in them is generated, smoothed, back-filled or estimated.

Where the prices come from

Neither endpoint allows a browser to call it directly, so the site carries one server function, /api/prices. It fetches, normalises and caches; it does not compute returns and it stores nothing. The line at the foot of each chart names the sources that actually answered, the bar size, and how long ago the response was fetched. Prices are delayed, and both providers are unaffiliated with this site.

How a set's return is computed

Each set is a fixed-weight basket, bought at the left edge of the chart window and held. With weights wᵢ from data/sets.json, normalised over the names the feed actually priced:

level(t)  = Σ wᵢ · Pᵢ(t) / Pᵢ(t₀)
return(t) = level(t) − 1

t₀ = the first stamp at which every surviving holding has a price

There is no rebalancing inside the window, no fee, no financing, no slippage and no dividend adjustment. The Rebalances row on a set page describes how such a basket would be run; it is not applied to the line you see, and the line should be read as buy-and-hold over the window.

Gaps, closed markets and missing names

Equities trade for about six and a half hours a day. Overnight, at weekends and on holidays their last print is carried forward — which is what a holder's mark does — so an equity-only line runs flat through those hours. A mixed set moves through the night on its crypto leg alone. That flatness is the market being closed, not data being filled in.

If the feed cannot price a name, its weight is dropped and the remaining weights are renormalised. The board then shows the covered share of weight in red beside the return, and the set page names the missing symbols. If nothing can be priced, the page says so and shows no number. Nothing is ever estimated to fill a hole.

The board ranks sets by this return over each set's own window, refreshed every five minutes. The today figure beside each set is its lead name's move since the previous close — the previous session for an equity, the last rolling 24 hours for a coin.

What is still generated

The counter strip, the Itamae page and the service log are a deterministic animation computed from UTC time and a fixed epoch, exactly as described below. They are a piece of interface, not a measurement of anything. The swap panel's rates are likewise illustrative and marked as such on that page. No part of the site places an order, holds an asset, or knows who you are.

The controller

Itamae is an eight-state population controller. Eight continuous rates in [0,1] advance on fixed 20 ms Euler steps:

u_i  = clip(drive_i + 0.10 · r_i)
r_i' = clip(r_i + Δt/τ_i · (u_i − r_i))

Input is a 32 × 16 synthetic field built from the bearing and distance of the active station, using a Gaussian contrast profile. Contrast is summed over each half of the field and over a central strip, giving left, right and centre features. The controller reads nothing else: not the board, not a price, not the page.

g      = 1 − 0.7·C                      approach gate
drive0 = L                drive1 = R
drive2 = 0.50·r0          drive3 = 0.50·r1
drive4 = 0.45·(r0 + r1)
drive5 = g·r0 + 0.12·r2 + 0.08·r4
drive6 = g·r1 + 0.12·r3 + 0.08·r4
drive7 = 0.55·(r5 + r6)

turn  ω = 3.2·(r6 − r5) rad/s
speed v = 0.15·r7 counter units/s

A controller that steers by bearing alone does not come to a dead stop; it settles into a small orbit around whatever it is approaching. Arrival is therefore measured as range rather than as a halt. A plate is recorded when three conditions hold together for 0.6 continuous model seconds: range to the active station below 0.07 counter units, knife rate above 0.02, and central contrast above 0.05. A plate then has a three-model-second cooldown, and the next station is drawn from the run seed. These are hand-set thresholds, not learned behaviour, and the controller has no view on the set whose name the plate is logged against — that name comes from a seeded rotation.

How sharing works

The usual way to show everyone the same live agent is a server process plus a websocket. Sushi Cate does not have one. Instead, service is divided into three-minute runs counted from the same fixed epoch, and the controller is fully deterministic: given a run index, the seed, the station order and every subsequent step follow with no free parameters.

So your browser does not receive the run — it recomputes it. Opening the page simulates from the start of the current run to the present moment: up to 9,000 model steps, which takes on the order of a fifth of a second, after which it continues in real time. Anyone else watching computes the same thing and sees the same chef in the same place. Closing the tab does not stop anything, because there was never anything running anywhere except the clock.

Because the field only covers what is in front of the chef, a controller that turns past its station receives no input at all, and with no input every rate decays to zero and it stops permanently. A small one-sided bias below an acquisition threshold makes it sweep until the station returns to view. Over forty consecutive simulated runs this produces between 1 and 16 plates per three-minute run and no stalls.

The trade-off is honest and worth stating: this is a shared computation, not a shared process. Nothing an observer does can influence it, there is no history beyond the current run, and a browser with a badly wrong system clock will be looking at a different run.

Swap panel

Token prices in the swap panel are smooth deterministic functions of the current five-minute bucket — two sine components per token over a fixed base. Price impact is an illustrative function of order size, the fee is a flat 0.30% of notional, and the network fee and route are generated for display. None of these figures correspond to a real pool, a real route or a real cost.

Token record

$SUSHICATE is an SPL token on Solana. Buying happens on a Solana DEX, not here. The mint address is the number to trust; copy it from the header, from the row below, or from data/token.json.

The Buy coin control in the header opens that swap. Trade, swap and sign-in controls on this site remain inert.

Limits

• Prices are delayed and are taken from free, unofficial endpoints. They can be wrong, stale or briefly unavailable. Neither Yahoo nor CoinGecko warrants them for any purpose, neither is affiliated with this site, and neither should be relied on for a decision that matters.
• A set's line is buy-and-hold arithmetic over those prices. It is not a fund, an index, a backtest, a track record or a quote, and no fee, financing cost, spread, slippage, dividend or tax is applied. Nobody has traded it and nobody could have.
• Weights are fixed editorial choices made when the sets were written; they are not maintained, rebalanced or reviewed, and a name that is delisted, renamed or acquired will simply stop pricing.
• A holding the feed cannot price is dropped and the rest renormalised, so a set showing reduced coverage is measuring something narrower than its stated composition.
• The counter, the Itamae page and the swap panel remain generated. The controller is eight coupled scalars: it is not an agent, it does not reason, and it has no view on any set. Set names attached to plates come from a seeded rotation, not from analysis.
• There is no persistence: no accounts, no positions, no stored history, and no record of a run once it ends. The price function caches responses for a few minutes and keeps nothing else.
• The arithmetic runs client-side, so a modified browser can produce different numbers locally. The prices it works from are checkable against the sources named above.

Credits & licence

The shared-deterministic-controller idea and the shape of the eight-state rate equations are adapted from the open-source Zebrafish Neural project (MIT), which in turn credits FLYBRAIN. No code, weights or data were copied from either; the equations here are reimplemented with different coefficients, a different input encoding and a different task.

The board and set-detail layout follow the pattern set by Pountain, and the swap panel follows the conventions of SushiSwap. Sushi Cate is not affiliated with, endorsed by or connected to any of them.

Market data is supplied by Yahoo Finance and CoinGecko, used through their public endpoints and credited on every chart. Neither is affiliated with Sushi Cate.

Built as plain HTML, CSS and ES modules with no build step, no framework and no runtime dependencies. The one server-side piece is api/prices.js, which has no dependencies either. Fonts are Inter and IBM Plex Mono.