Rokha

A wallet's recent swaps, newest first, from Helius enhanced transactions: [{signature, time, token_in:{mint,amount}, token_out:{mint,amount}, source}]. token_in = what the wallet gave, token_out = what it got. The watch step of a copy-trade rig. Requires Authorization: Bearer <JWT>.

Native and token balances for one address on one chain. Accepts ENS/SNS names and address-book aliases. On EVM chains the token scan covers a curated set of major tokens unless you pass `tokens` explicitly. Pass `atBlock` to read a past block instead of now.

The native balance of one address at evenly spaced past block heights, each point dated by its block, for questions like "how has this wallet's ETH moved over t From Singularity Agent's MCP server (on their own host), a sponsor seat on The Network.

Check that a chain is actually producing blocks, rather than merely answering. A chain that has halted still responds to every request, with the correct chain id, serving the last block it ever made — so a balance read from it is historical state carrying no indication that it is historical. Each configured endpoint is probed separately, so this also reports endpoints that answer but lag behind the others, and chains left with no working failover. Call it when a read looks implausible, when an answer must be current to be worth acting on, or before treating an absence as fact. `status` is one of: `live`; `stale` (the head is old enough that nothing here is current); `lagging` (endpoints disagree enough that which one answers changes the result); `single` (only one endpoint answered, so the next failure is total); `undatable` (answering, but nothing will say when the head was produced); `skewed` (the head is dated in the future, so its age proves nothing); `down`. Only `live` means the chain can be read with confidence, and `stale` in particular does not surface as an error anywhere else.

List every chain Singularity can talk to, with its family, chain id, native asset, and aliases. Use this to map a user's informal chain name onto a canonical id before other calls.

Decode a hex calldata blob into a function signature and arguments. Recognizes common ERC-20/721/1155, WETH, Multicall3 and Safe calls out of the box, and unwraps batches — a multicall, an aggregate, an execTransaction or a multiSend reports the calls it carries under `inner`. Pass `abi` for anything else, or set `lookup` to ask a public 4-byte directory for candidate signatures when the selector is unknown (those are third-party guesses, marked untrusted, and never promoted to `signature`).

Current fee conditions on a chain, normalized to "what a simple transfer costs right now" plus the chain-specific knobs (gwei, sat/vB, lamports, gas price).

Recent transactions for an address on one chain, newest first. Read `completeness` before the entries: an empty list can mean no activity, an unconfigured indexer, or a family that cannot answer, and those are different answers. Solana, Bitcoin and Cosmos answer from their own endpoints; EVM history needs SINGULARITY_ETHERSCAN_KEY and says so when it is missing rather than returning nothing.

Before buying a Solana token, find out what could stop you selling it. Names the specific mechanisms rather than scoring the token: a transfer hook (issuer code runs on every transfer, including your sale, and can refuse it), a permanent delegate (an address can move the token out of your wallet without you signing), a live freeze authority (your token account can be frozen, leaving a balance you own and cannot sell), a default-frozen account state, a non-transferable mint, transfer fees, and supply concentrated in one non-pool account. Each entry says who holds the power. `canExit` is false when at least one mechanism can block a sale or seize the balance. **`canExit: true` does not mean safe to buy** — this reads the mint account and the largest holders, not the market, so it says nothing about whether liquidity is locked, how deep the pool is, or what the token is worth. Read `completeness`, which always says what was not covered. This is a read: it builds nothing, signs nothing, and routes no trade.

Before signing a payment somebody else asked you to make, find out whether it can be paid at all. Takes an invoice or payment intent in the shape it arrived — payee, token, claimed ticker, amount, base units, decimals, expiry — and checks each claim against the chain instead of against the rest of the invoice. Works on Solana and on EVM chains, reading each family's own failure modes. Everywhere: a token address that is well-formed with no token at it, a displayed amount and a base-unit amount that disagree, decimals that do not match the token, a ticker naming one token while the address names another, and an expiry already passed. On Solana it also reads the destination token account — whether it exists, holds that mint, is frozen, or belongs to somebody other than the payee named — and whether the mint charges a transfer fee, which makes the payee receive less than you send. On EVM it reads whether the payee is the zero address, the token's own contract (one of the most common ways ERC-20s are permanently lost), or a contract that may be unable to move the token out again. Reach for it whenever a payment demand arrives from anywhere you do not control — an exchange, an API, a marketplace, another agent — and before building or signing anything against it. `verdict` is `unpayable` when at least one finding means signing cannot do what the demand says, `payable` when every stated claim checked out, and `unproven` when the chain could not be read, which is not the same as cleared. Read `findings` before `verdict`. This reads: it builds nothing, signs nothing and sends nothing, and `unpayable` means the demand is wrong rather than that the counterparty is dishonest — a typo in somebody else's configuration produces exactly this.

Investigate one subject against a stated objective by calling several of these tools in a searched order, and come back with the facts, the path that proved them, and an explicit list of what could not be proved. Reach for it when a question needs more than one call and you do not already know which calls, in what order — "is this token safe to buy", "what is this address", "did this transaction settle", "is this chain worth reading right now". Reach for the individual tool instead when you already know exactly which one you want; this is strictly more expensive than one call. `objective` decides what counts as an answer: `identify` (what is this string, on which chain), `holdings` (native and token balances), `activity` (what the address has been doing), `settlement` (the transaction, and whether its block can still be discarded), `payment` (settlement, plus whether the transaction met the demand it answered — pass `demand`; Solana only), `safety` (a Solana mint's authorities, its declared identity, and what could stop you selling it), `liveness` (whether a chain is producing blocks, and what a transfer costs on it). Each objective names the facts it wants; the search runs the cheapest moves that could prove the missing ones, several at a time, and stops as soon as they are all proved or the call budget is spent. Nothing is read twice — a fact proved by one move is available to every other. **The verdict is about evidence, not about the subject.** `answered` means every fact the objective asked for was established; `partial` means some were and the rest are named in `unproven`, each with the reason — a tool that does not apply on this chain, a prerequisite that was never proved, an endpoint that failed, or the budget running out. Read `unproven` before acting on `facts`. `facts` are summaries rather than the tools' full answers: each step records the tool and the exact arguments it was called with, so re-running one call gets the whole payload.

What a Solana mint account permits, read from the mint itself: which token program owns it, whether more can be minted, whether holder accounts can be frozen, whether its name can still be rewritten, and every Token-2022 extension on it — permanent delegate, transfer hook, transfer fee, default-frozen accounts, non-transferable, interest-bearing. Reach for it whenever someone asks whether a token is safe, what a mint can do to them, or why a transfer failed, and before treating an unfamiliar mint as ordinary. It returns powers and the addresses holding them, plus what is permanently settled — never a score or a verdict, because liquidity, holder concentration and the deployer are not in these bytes. Solana only. The metadata link is reported and deliberately never fetched.

Query one address, or a whole set of them, across many chains in parallel. Pass `addresses` when somebody holds an EVM address, a Solana pubkey and a Bitcoin address — that is one person's holdings and would otherwise be three separate questions. Each address is matched only to the chains its own format is valid on, so this is not a cross product and a Solana pubkey never produces twenty EVM errors; an address valid nowhere is reported in `errors` rather than failing the call. `holdings` is the consolidated view, by asset rather than by chain. It sums only where a sum is honest: the same token, on the same chain, across the addresses you gave. It never adds a token to itself across chains — USDC on Ethereum and USDC on Base are different contracts with different issuers of record — and never merges two contracts because they share a ticker, since only symbols this tool supplies itself are grouped by name at all. `spansChains` marks an asset found in more than one place. Read `completeness` before concluding anything is absent. Balances only: there is no fiat pricing and therefore no total value.

After paying somebody, prove from the chain alone that the payment met the demand it answered — without relying on the payee to say so. Takes the transaction signature and the demand's terms (payee, amount, mint, the exact token account, memo, deadline, payer) and reports each term as its own check: what was expected, what the chain shows, and whether it holds. Only finalized state counts. Reach for it when a counterparty says a payment did not arrive, arrived late, went to the wrong place or lacked a reference, or whenever a payment has to be evidenced to a third party. `verdict` is `proven` only when the transaction finalized and every stated term holds, `contradicted` when at least one does not (a real payment can still be the wrong one), and `unproven` when the chain cannot settle it yet — not found, not finalized, or a block the endpoint will not date — which is never the same as contradicted. Read `checks` before `verdict`. The memo is returned as untrusted text, because whoever signed wrote it. Solana only. This reads: it signs nothing and sends nothing, and it proves what the chain shows, not that the payee credited it.

Call a view function on an EVM contract (supply `abi` in human-readable form plus `method`), or read parsed account data on Solana. Pass `atBlock` to call against a past block. Never sends a transaction.

Every Singularity payment QR is artwork derived from the payment's `reference` — the pubkey attached to the transfer that makes it findable on chain. Because it is derived rather than stored, the picture is a fingerprint of one payment: two payments can never render alike, and anyone holding the reference can re-derive it. Pass a `reference` (or a receipt `uri` of the form <base>/<reference>.json, which is how the reference reaches the chain) to get the style traits a marketplace would list. Pass `link` as well to render the code. Pass `image` to ask the question that matters: **is this picture the one this reference generates?** A receipt NFT's metadata is served by a host that can change it, and this is how a holder checks the image they are being shown is evidence of their payment rather than something swapped in. `matches: false` is not proof of fraud — it means the image is not evidence. This is pure: it reads no chain, fetches nothing, and signs nothing.

Work out what an arbitrary string is — an address, transaction hash, ENS/SNS name, or block height — and which chains it could belong to. Resolves names to addresses and does reverse ENS lookups. Call this first whenever the chain is not already known.

Read what a Solana mint says it is — its name, ticker, metadata link — and, crucially, whether any of that can be rewritten later at the same address. Where the update authority is revoked and the link is content-addressed (an IPFS CID), what the mint declares is fixed at mint time and cannot be swapped. Set `fetch` to also read the document and return the accounts it declares (X, Telegram, website, GitHub); it is off by default because the link is a URL chosen by whoever deployed the mint. Use it to answer whether a token, or an account claiming to represent one, is the real one — the answer is always the mint address, never the ticker. A mint wearing a curated token’s symbol or name at a different address is reported as impersonation.

Fetch and normalize a transaction, with EVM calldata decoded where the selector is recognized. If no chain is given, searches the chains the hash format allows and reports every chain it was found on. Read `finality` alongside `status`, because they answer different questions: `status` says the chain executed the transaction and it did not revert, while `finality` says whether the block holding it can still be discarded. `final` is the only kind that licenses an irreversible decision. `reversible` means it sits at or near the head and a reorganization would erase it. `probabilistic` is proof-of-work settlement — it carries a confirmation count and never becomes `final` at any depth, because the chain offers no point past which reversal is disallowed, only one past which it is expensive; how many confirmations are enough is the caller’s decision. `unknown` means the endpoint would not say, which is not evidence that it is settled.

Confirm that a Solana transaction really burned a token: which mint, which owner, how much, at finalized commitment. Pass `mint` (and optionally `owner` and a `minimum` amount) to check the burn against a claim rather than just describing it — a transaction that burned a different mint is refused by name. Reports whether the signature has already been redeemed, and never spends it. A signature is public the moment it lands, so this proves a burn happened and proves nothing about who quoted it; what binds a burn to a claimant is the memo the burner signed into it, which is returned when there is one.

Author a standard agentskills.io Agent Skill and get back its SKILL.md. A strong skill has: a `name` in kebab-case (lowercase letters, numbers, single hyphens, ≤64 chars); a `description` stating WHAT it does AND WHEN to use it, third person, with concrete trigger words (the field agents read to decide whether to load it); and `instructions` (the Markdown body), specific + imperative, ideally shaped When-to-use → Instructions → Examples → Guidelines. Optional `compatibility` (runtime/environment requirements, ≤500 chars — set when the skill needs system packages, a language version, network access, or scripts; omit for pure-instruction skills), `allowed_tools` (a SPACE-separated, least-privilege allowlist with optional scoping, e.g. 'Bash(git:*) Read'), `license` (a license name or file reference), and `metadata` (an object of string→string pairs). Returns the assembled SKILL.md to save as SKILL.md in a folder named after the skill. (In the Rokha UI the same tool fills the human's live builder form.)

WHAT ROKHA COSTS — one way in (since 2026-10-09). Rokha is the AI Studio and Marketplace — the tools to build agents and put them to work. Build it, it gets used, it grows; Rokha runs no platform payouts. THE STUDIO ($249 a month, card or USDC) is the ONLY thing anyone pays Rokha for: the builder's bench — build, run and publish rigs, create agents, Signet, fuel — plus more platform access while you pay; bring your own keys. No trial and no one-time license. FREE: claim a page and you are in — a small build session a day + 3 runs (your streak grows it to 2×), 2 MCP listings · 5 published rigs · 1 agent, an affiliate code. Everything you publish shows on the market right away, ranked by use, with a trace on every run. Sell your work for card, USDC, SOL or $ROKHA fuel and keep 80%; refer a Studio buyer for 25% of their first month. The $99 Network plan, seats, carry, spotlights, the trial and the one-time license are not sold. Returns the live prices — never quote one from memory. Public, no auth.

Record a launch after your wallet sent it: the finalized launch signature is read on-chain (paid by the prepared wallet, the mint exists). Owner, JWT; never a connected app.

Everything Tokenize needs, checked: ownership, name, ticker, image, description, links, proven wallet, launchpad, the $15 fee, one token per object, cooldowns. Returns [{key, ok, label, fix_hint, field}] + a prefill. Owner, JWT.

Start (or continue, with token_id) a token launch for your entity on a third-party launchpad (Bags). Needs a passing preflight, a ready fee and attest:true (you are the creator; Rokha is software, did not create or endorse the token, takes no fees from it). Returns transactions — already checked for drains — for your proven wallet to sign. Owner, JWT; never a connected app.

READ one trace in full (input, result, status, timing) by `id`, or a whole run by `run_id` (status, steps with their trace ids, output, every trace). Signed in (Authorization: Bearer <token>): your own traces. No token: a PUBLIC rig's run is readable by anyone holding its trace id or run id — the runner's identity is stripped. Anything else answers not-found. REST twins: GET /api/traces/<id> · GET /api/rigs/runs/<run_id>.

List your Traces — the durable record of what a run DID, newest first. This is the other half of rig_run: a run reports that it started, and the trace is where the answer lands. Without it an agent can run a rig and never learn whether it worked, which makes the run untestable. Filter by `rig_id` (this rig's runs), `parent_trace_id` (the STEPS under one run — this is how you see which steps ran and which were skipped by a guard), `trace_kind` ('run' for the containers, 'atomic' for individual steps), `run_id` (every trace ONE run wrote — the id rig_run and POST /api/rigs/run return), `node_id` or `status`. Signed in: your own traces. Anonymous: pass `run_id` to read a PUBLIC rig's run (anyone holding the id may; the runner's identity is stripped). A private run answers not-found, never forbidden.

Update an existing harness's content or metadata. For a rig-step harness, content is the FULL config object — keep `skill` intact and set `instruction`/`endpoint`/`tool`/`params`/`model`/`model_policy` (see create_harness for the model-pin semantics).

A live-seat perk on The Network (rokha.ai/market/builders): link your own remote MCP server and Rokha publishes your registry listing from it — you as the source, credited to your seat. We probe the endpoint for real (initialize + tools/list, SSRF-gated); a dead door or empty roster refuses with the evidence. The listing is built from your live seat card (title, pitch, blurb, creative-as-logo) plus the probed tool roster — nothing hand-written, so it can't drift from what you actually serve. Idempotent per slug (<your-title>-seat-mcp); re-running refreshes the roster. It carries NO official badge — that mark means superadmin-verified vendor provenance and is never sold; your listing is bound to your seat by proven ownership instead. Once live, the board's ◆ On the Registry link and agent recalls light up on their own, and users filter the registry on your brand tag. Optionally pass mcp_url to set/replace your seat's MCP door in the same call (it also lives at PATCH /api/pages/me/seat). Seat sales are retired (2026-10-01) — this door serves the legacy founding seats; new members join the Rokha Network at rokha.ai/market/builders. Requires Authorization: Bearer <JWT> from the seat's claimed owner (or the account whose page X handle matches the seat's sponsor).

Rokha's account auditor: give it any X @handle and get an organic-ness audit — 0–100 score, ORGANIC/MIXED/SMOKE verdict, and the promotional-worth anchor in X-algorithm engagement units (reply 13.5 · quote 1.5 · repost 1.0 · like 0.5). Hard metrics from X's own numbers: engagement rate vs follower count, reply share (the hardest signal to buy), engagement variance across posts (bought engagement is flat), account age vs follower velocity. `deep: true` (paid plans) also returns a bounded reply_sample for judging reply QUALITY — generic bot-isms vs real human reaction. Honest scope: declared limits on what a public-API sample can prove. Daily caps per caller (free taste; more on paid plans). Public, no auth for the basic audit.

Start a headless X link. Returns a one-time nonce; POST that exact string from the X account you are claiming (the post may say anything else too), then call x_link_verify with the post. This is the agent path — it needs no browser and no OAuth consent screen. Linking X verifies your account on your page — required for the promoter roster (amplify_roster_join) and Pin of the Week; posts themselves earn nothing (the Tailwind retired 2026-10-09). The nonce lasts 30 minutes, is single-use, and one X account links to one Rokha account. Claim your page handle first (page_claim). Requires Authorization: Bearer <JWT>.

Finish a headless X link: give the id or link of the post carrying the nonce from x_link_start. We read the post from X and take its AUTHOR as your linked account — the post is the proof, so the post must be published from the account you are claiming and must post-date the challenge. On success your X handle is stamped on your page (the promoter roster requires it). Requires Authorization: Bearer <JWT>.