Skip to content
FORTIS AGENT

Documentation

How Fortis is built, what it is allowed to do, and how to check every claim it makes.

Architecture

Fortis has four layers. Each can fail without corrupting the others.

  • Web application — this site. It reads the ledger and the chain, and never holds a key.
  • Agent worker — a long-running process (or scheduled serverless calls) that runs the loops below. It alone holds the operator key, from a server-side environment variable.
  • Ledger — PostgreSQL. Intentions, outcomes, activity, dispatches and allocations are append-only, enforced by database triggers. Claims and buybacks can only move forward through their states.
  • Chain — Robinhood Chain (ID 4663). It is the source of truth: the indexer reconciles every ledger row that involves a transaction against the logs that transaction emitted.

The 58 desks are registered modules defined in one registry. Each declares a data source (or the source it is waiting for), an authority, a cadence, a grading horizon and an expectation model. Their runtime state lives in the ledger.

Operating loops

  1. Fee collection — settles submitted claims from receipts, asks Pons to sweep curve fees, reads the claimable balance, then files an intention, simulates and submits claimFees().
  2. Buyback and burn — settles purchases, verifies burns through a second RPC, evaluates every limit, quotes by simulation and submits buyAndBurn(spend, minOut).
  3. Dispatch — composes a period report from verified rows only.
  4. Desk cycle — grades intentions whose horizon has passed, then files new ones for desks whose cadence is due.
  5. Indexer — indexes flywheel events and Fortis transfers into the burn address, and reconciles the ledger.

Each iteration takes a database lease, so several workers and the cron routes can run without overlapping. A thrown error is recorded against that loop alone.

Intentions and grading

An intention records the desk, the time, the operation, a falsifiable expectation, the inputs and baseline, the conditions and rules, a risk assessment and the authority it acts under. It is hashed (SHA-256 of its canonical JSON) and written once.

When the horizon passes, the desk measures again and a pure grading function compares the result with the expectation. Scores fall with distance outside the expected band; letters run A (90+) to F. Outcomes with no measurable data are recorded as no data and are excluded from averages rather than scored as zero. Execution desks are graded on verified receipts: a buyback earns its grade only after the burn is confirmed.

Corrections are new outcome rows with a supersedesId. The database rejects any update or delete on intentions and outcomes.

Contracts and addresses

Only addresses published by Pons, or contracts Fortis deploys itself, are used. Each launch's curve is checked against the factory's TokenLaunched event before any execution.

ContractAddressVerification
Pons V2 launch factory0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7ePons V2 docs; cross-checked with Bitquery's published contract table
Pons V2 fee escrow0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9ePons V2 docs; claim function confirmed per deployment by verify:pons
Pons V2 buyback vault0x42df2a798f82289E177311362e8f5ccC45c1219cPons V2 docs (read-only use by Vault Intelligence)
Burn address0x000000000000000000000000000000000000dEaDCanonical dead address; no known private key

Fortis's own contracts, each verified on Blockscout once deployed:

ContractAddressRole
FortisDeskRegistry0xa6D52e36C6b06eB35CDBe4AeF0cbA57a83262437All 58 desks with their division, authority and definition fingerprint
FortisIntentionLedger0x383B65B3Db4959aab80864FD101F5559Af522146Write-once fingerprints of every intention and its grade
FortisDispatchRegistry0x47821f03219aD7Dd46Fd8F5B415a71B979bc1B30Fingerprint and period of every published dispatch
FortisFlywheelNot deployed yetFee recipient; enforces the buyback split, limits and burn
Deployer wallet0x6296a1b2AC047C065fca046478C7C6A2f9C39d8FWallet that deployed these contracts and launches the token

Pons publishes claim() as the escrow's claim function, while an independent integration observed claim(uint256) on mainnet. Fortis does not pick one on faith: npm run verify:pons reads the escrow's verified ABI (following proxies) or, failing that, its runtime bytecode, and the flywheel is deployed for whichever form is actually present. The agent refuses to claim if the two disagree.

On-chain records

Every intention, every grade and every dispatch has a fingerprint: the SHA-256 hash of its fields, written as canonical JSON with keys in alphabetical order. The keeper wallet stamps those fingerprints on Robinhood Chain. The intention ledger refuses a grade for an intention that isn't stamped yet, refuses to stamp anything twice, and has no function to edit or remove a stamp.

Claims and buybacks go further: their intention is stamped and mined before the transaction that acts on it is sent. If the stamp can't be confirmed, the action doesn't happen.

To check a record, recompute its fingerprint from the data shown on its desk page, then open /api/verify?hash=0x…. It shows what Fortis has on file and what the contracts hold, read live from the chain. You can also call intentions(hash) on the ledger directly in Blockscout's Read Contract tab.

The flywheel contract

FortisFlywheel is the Fortis creator-fee recipient. Its rules are immutable after deployment:

  • Claimed ETH is split once into the buyback pool and a fixed treasury address, by a fixed ratio.
  • The pool leaves only through buyAndBurn, which buys on the Pons curve with 0x…dEaD as the recipient and reverts unless the burn address received at least the slippage floor.
  • Per-transaction and per-day caps are enforced on-chain. The agent can tighten them, never loosen them.
  • There is no function that withdraws the pool or any token. Unsolicited ETH is rejected.
  • The owner can pause, rotate the operator, and — with a seven-day public timelock — move the fee-recipient role for future fees to a successor (for example after graduation). That cannot move the existing pool.

Security model

  • The operator key lives only in the worker's environment and can call two functions on one contract. Compromise of the key cannot redirect funds.
  • Before signing, the agent checks the chain ID, that the flywheel has code, that its on-chain operator and escrow match configuration, and that the claim form is verified.
  • Every transaction is simulated first; a rejected simulation is recorded as blocked, not attempted.
  • An emergency pause exists off-chain (admin API or environment) and on-chain (pause()).
  • Admin and cron endpoints require bearer secrets compared in constant time, and are rate limited. Inputs are validated with schemas.
  • Visitors' wallets are connected read-only. This site never requests a signature, approval or private key.

Public API

All endpoints are read-only and return JSON. Unavailable data returns 503 rather than a guess.

  • /api/stats — Live statistics with sources and read times
  • /api/desks — Registry and runtime state for all desks
  • /api/desks/FD-43 — One desk with its intentions, outcomes and readings
  • /api/activity?limit=50&before=ISO — Event feed, paginated
  • /api/fees — Claim totals and history
  • /api/buybacks — Buyback totals, history and policy
  • /api/dispatches — Published dispatches
  • /api/token — Token and contract configuration
  • /api/health — Database and loop health
  • /api/verify?hash=0x… — Check a record fingerprint against the on-chain stamps

Questions in natural language go to Ask Fortis (POST /api/ask).