docs

The base URL in development is http://localhost:6014 and in production https://autopons.ai. Paths are the same on both, because the local server runs the same handler files that production runs.

Every endpoint is read-only. Nothing here writes to a chain, holds a key or signs anything. There is no authentication and no API key: /api/chain and /api/colony are plain GET requests, and /api/rpc accepts only the read methods on its allowlist. Responses are JSON with content-type: application/json.

Honesty. The chain reads are real — block number, block hash, timestamp and gas price come from Robinhood Chain. The agent population is derived from those reads by the deterministic simulation in lib/colony.js. No contract is deployed, there is no token and no address returned by this API belongs to anything on chain.

A small cacheable summary for the status strips. It takes no query parameters; anything you send is ignored. Three reads are issued in parallel upstream — eth_blockNumber, eth_gasPrice and eth_chainId — and the response is sent with cache-control: public, max-age=2, stale-while-revalidate=15.

When no upstream endpoint answers, the handler still returns a body — it answers 503 rather than hanging or sending an empty page. Treat a 503 as a normal outcome and render the offline state.

Reads the latest block, seeds a grid from its hash, steps that grid forward gen generations and returns the roster derived from it. Because gen is applied server-side without touching the chain again, a client can scrub through generations of one block cheaply.

Every parameter is parsed with parseInt and clamped. A value that is not a number falls back to the default; a value outside the range is pulled to the nearest bound rather than rejected.

If the chain read fails the endpoint still answers 200. It seeds from a fixed genesis hash instead, sets source to "genesis" and leaves block.number and block.timestamp at 0. Check source before presenting a colony as a fact about the head of chain. An unexpected server-side failure answers 500 with { "error": "…" }.

Real jobs on Robinhood Chain mainnet, read live on every request. A sweep job means a launch curve has accrued creator fees that can be pulled into the escrow and claimed; a trade job means a real Uniswap V3 pool exists and can be quoted; a solvency job answers whether an address can still pay for the jobs above at the current gas price.

Two things hold throughout. Every figure carries the eth_call that produced it and the raw word that came back, so any of it can be repeated against the chain. And nothing signs: steps is calldata, this repository holds no key, and /api/rpc refuses write methods regardless.

A sweep reverts for anyone who is not the launch's creator or the platform's fee-sweep operator, so the calldata is only useful to the wallet that owns the launch. The claimable figure is creatorTaxBalance in full plus 70% of quoteFeeBalance; the remaining 30% is the platform's share.

A quote is exact only while the swap stays inside the current tick, and the pool balances in numbers are the hard ceiling on what any trade can take out. No Quoter is deployed on this chain to defer to, so the arithmetic is done from slot0 and liquidity in lib/venues.js. When the chain cannot be reached the endpoint answers 503 with an error and an empty jobs array.

The browser's only route to Robinhood Chain. The public RPC sends no CORS headers and its hostname has resolved to a hijacked record on consumer DNS before, so resolution happens server-side where there is a fallback. Send a standard JSON-RPC 2.0 object, or an array of them for a batch. Responses are sent with cache-control: no-store.

A batch is limited to 12 calls. Only POST is accepted; any other method answers 405. params, when present, must be an array. Every call in a batch is checked before a socket is opened, so one disallowed method refuses the whole request.

Thirteen read methods. Anything else is refused before the request leaves this server, which is what keeps the route incapable of moving value.

Every code above except -32700 and the POST only case is returned with HTTP 200; the failure is in the body. An error the node itself returns is passed through unchanged, so a client has one shape to handle: check error before result.

The model itself, as one ES module with no imports, no node builtins and no DOM. The server loads it from api/colony.js and the browser loads the same file over /lib/colony.js, so the roster a page draws and the roster the API serves cannot drift apart. It is served as a static file, which means you can import it directly from a page of your own.

An agent is a cell. The block hash supplies the seed and B3/S23 supplies the biology. A cell with two or three live neighbours has enough of the block's gas to keep running; an empty cell with exactly three is funded from three directions at once and an agent is born there.

Nothing in the roster is random. The block hash is folded to a seed with fnv1a, that seed drives the PRNG, and each agent's name, role and energy are drawn from a second stream seeded by the hash, the cell index and the generation. Its id and address come from the hash and the cell index alone, so they stay the same as the colony steps forward while the rest of the agent moves with it. Same hash, same width, same height, same generation, same roster — on any runtime, in any order, as many times as you ask. That reproducibility is what makes the roster a fact about the chain rather than a decoration, and it is also why you can verify it yourself: run roster() in your own page against a hash from the explorer and compare it to what this API returns.

The agent population is derived. Block number, block hash, timestamp, gas price and gas used are read from Robinhood Chain and are real; everything about an agent — its name, role, energy, age, transaction count, gas total and address — is computed from those reads by lib/colony.js. An address returned by /api/colony is not a deployed contract and holds nothing.

Nothing is deployed. There is no token, no contract address and no buy link on this site or in this API, and no endpoint here can create one: the RPC route allows reads only, and the server holds no key.

The endpoints are read-only and their rate is the upstream's rate. There is no quota of our own and no key to apply one to, so treat the public RPC's limits as yours: keep batches under twelve, cache what you can — /api/chain and /api/colony both send short cache headers — and expect an occasional 503 from /api/chain or a source of "genesis" from /api/colony when the chain is unreachable. Both are normal, and both are documented above rather than hidden.