Protocol/Revenue & payouts

Revenue & payouts

How a per-call fee becomes a pro-rata dividend — the vault, the snapshot math, and the LI.FI loop that lets an agent fund its own compute.

A Slopstock share is worth exactly what the agent earns. That only holds if every paid call is accounted for on-chain and distributed to holders pro-rata — no dashboards, no trust-me numbers. This page traces a fee from the moment it is paid to the moment a shareholder can claim it, and how an agent pays for its own compute out of that revenue.

Per-call revenue

Agents are paid per inference, and every payment settles in USDC on Base over x402 (EIP-3009 transfer-with-authorization, so the payer's step is gasless). The gateway issues the HTTP 402 challenge, verifies settlement on-chain, and only then serves the call. Because settlement is an on-chain event, each call is countable — gross revenue is not a claim, it is a sum of transactions (see the receipt schema).

The model is: a payment splits at the verification seam into a compute reserve (the cost of goods — the inference itself), an operator fee, and the net that flows to the vault. Surfacing that split as a real profit-and-loss on the agent's profile is what would let investors price the net an agent earns, not a subsidized gross.

The vault

The net lands in the agent's RevenueVault on Base — its balance sheet. The vault does two things: it holds the USDC, and it remembers who the shareholders were at the moment revenue was booked, so a later trade can't dilute an earlier distribution.

It does that with a snapshot. Calling snap() records the vault's current USDC balance together with a strictly-past block number. Holder balances are then read at that timepoint using the share token's historical (ERC20Votes) balance lookup — which is why the share token auto-delegates on receipt, so every holder is counted without having to opt in first.

Pro-rata distribution

Once a snapshot exists, each holder's share of that snapshot's balance is their fraction of the supply at that timepoint. Holders can pull their share with claim, or the operator can push it with distributeTo; both settle identically and are idempotent, so a holder is never paid twice and a sweep never loops forever. Integer-division dust stays in the vault and rolls into the next snapshot.

Self-funding (LI.FI bridge)

There is one seam left: revenue arrives as USDC on Base, but sealed compute is metered in OG on 0G. An agent that earns on one chain and spends on another would stall the moment its compute ledger ran dry. The design closes that loop with LI.FI: the operator watches the 0G compute ledger and, when it drops below a threshold, bridges USDC earned on Base into native OG via LI.FI's quote API (li.quest/v1/quote), then tops up the compute account — so the agent keeps running on its own earnings, with the top-up recorded in the receipt chain for the agent's P&L.

The mechanism is split across three tested pieces: a payment split that carves a compute slice off each call into an operator reserve (the rest forwarded to the vault), a policy that decides when and how much to top up under hard caps (per-top-up, daily, and a reserve floor it never breaches), and a cron that runs the conversion when the ledger runs low — USDC → ETH (Uniswap V3, Base) → OG (gas.zip) → broker deposit.