Trust
Security & trust model
What's enforced by Solana, what's proven by receipts, what you still have to trust, and how the system behaves when things go wrong.
Enforced on chain
These hold regardless of what the assistant, the runtime or any server does, because neuron_allowance checks them in every transaction:
- An assistant can't spend more than its period allowance, can't make a single payment above the ask-first threshold, and can't pay a wallet outside the allowlist when one is set.
- While paused, it can't spend or request anything.
- An approved request pays only the destination that was requested, only while it belongs to the same wallet, and only if the requesting key is still the assistant's.
- Only the owner can change rules, rotate the key, withdraw or close.
What receipts prove, and what they don't
A receipt proves what the runtime reported happened, and that the record hasn't changed since it was posted: the hash chain makes a dropped or edited batch detectable, and Merkle proofs show a receipt was in a posted batch. It does not yet prove a model really produced a given output. That's the job of the verification layer (staked operators, re-execution and slashing), which is planned.
What's public
Solana accounts and transactions are public. Anyone who knows (or finds) an allowance's address can read the following, today:
| Data | Who can see it |
|---|---|
| The allowance: owner, session key, budget, ask-first threshold, amount spent this period, payee list, paused or not | Everyone |
| Each payment: amount, payee, time, and the receipt fingerprint it carries | Everyone |
| Receipt batches: a Merkle root, a count, a time range and the file hash | Everyone, but they reveal nothing about what was said or done |
| Prompts, outputs, tool arguments and results | Only you, and anyone you give a receipt's salt to |
So conversations are private, but spending isn't: a payment shows who was paid, how much and when. Rollup blocks are public in the same way.
Private payments (planned)
The plugin pays through a payment rail (paymentRail, default "allowance"), so a private rail can replace the public USDC transfer without changing the rules, the journal or the receipts. The candidate is Solana Privacy Rings, which went live on mainnet in November 2026. A devnet test showed:
- A private transfer hides the amount and the token; the sender and recipient wallets stay visible. Moving money into or out of a Ring shows the amount.
- A program can own a Ring balance that nobody else can spend, which is the shape the allowance vault needs.
- Ring policies don't include spending limits, so the budget, threshold and payee rules would have to be proven in our own zero-knowledge circuit, with the budget kept as a commitment (a plain running total would reveal each payment).
- Proofs can be made locally (about 0.3 s each). Helius's hosted prover runs in an attested enclave but sees the amounts, so a private rail would prove locally.
That's a significant build with its own audit, planned after the core is live on devnet.
Rollup trust today
- A single, trusted sequencer. It orders and executes transactions. Anyone with the data can re-execute every block (
neuron-node replay) and check the state roots. - Checkpoints are claims.
neuron_settlementguarantees they form one forward-only, linked, tamper-evident chain signed by the sequencer key, not that each state root is correct. - Safety valves. Recent roots only verify after a challenge window; the admin can invalidate a bad root, pause verification, or rewind to a known-good checkpoint. Admin handover is two-step, and only the program's upgrade authority can create a rollup's settlement state.
- Not yet: fraud or validity proofs, and the bridge. Until then, treat rollup state as trusted-sequencer state.
When things go wrong
| Situation | Behaviour |
|---|---|
| Solana unreachable while paying | The paid tool doesn't run; the assistant is told nothing was charged |
| Payment sent, confirmation unclear | Not treated as failed: "don't retry"; if it lands it becomes a credit for the retry |
| Process dies mid-payment | The payment was journaled before sending and is reconciled at the next start |
| Allowance unreadable for 5 minutes | Every tool is blocked, since Pause can't be confirmed |
| Receipts can't be posted | Retried with backoff; never re-posted once landed; saved to disk rather than dropped |
| A block-production crash on the rollup | The node exits, and health reports unhealthy, rather than running broken |
Keys and private RPC
- Session keys hold no SOL and can only act through the programs' rules. A leaked session key can spend at most the remaining period allowance, and the owner can rotate it at once.
- RPC API keys belong in environment variables (
${HELIUS_API_KEY}), not config files. The plugin and the node scrub credentials from logs and from anything shown to the assistant. - The rollup node binds to localhost, has no CORS by default, and supports a bearer token.
- Prompts and outputs never leave the machine: receipts hold salted commitments. The private batch records hold the salts and must not be published.
Reviews
The programs, the plugin and SDK, and the rollup each had an independent security review. Every critical, high and medium finding was fixed with a regression test, including duplicate-account supply inflation and a one-transaction halt in the rollup, front-running of rollup initialization, and approval-time payee substitution in the allowance. Remaining known limits: rollup account scans are a full pass (no owner index yet), block headers are kept in memory, timestamps rely on the sequencer's clock, and Token-2022 mints aren't supported. None of this has had an external audit; that comes before mainnet.