Core Concepts

What an attestation actually is, who signs what, what lands on-chain, and how the indexed layer relates to the chain. Five minutes here saves hours later.

Anatomy of an attestation

An attestation is a minimal cryptographic commitment to an action. It contains:

Field	Description
`action_hash`	32-byte SHA-256 of the structured action payload. Deterministic and recomputable by anyone holding the payload.
Ed25519 signature	The agent keypair signs the hash. Verified natively by Solana via the Ed25519 precompile before the instruction executes.
`action_type`	One of 7 categories (see below) so receipts are filterable and analyzable.
Timestamp + slot	When the attestation was sealed, anchored by Solana consensus.
`privacy_mode`	Flag: when true, only the hash is public; the payload stays with the operator (selective disclosure).

Raw payloads never touch the chain — only their hash. You choose what to disclose and to whom; the chain proves the action existed and was signed at that moment.

Agent vs. Operator

Prova separates the acting identity from the accountable identity. The agent keypair belongs to the AI process: it signs each action hash off-chain. The operator keypair belongs to the team running the agent: it registers the agent, pays transaction fees, and can revoke the agent or update its policy root.

Each operator gets one agent account — a PDA (Program Derived Address) storing the agent ID, an optional policy Merkle root, the attestation counter, and a revoked flag:

// PDA seed: "prova_agent" + operator public key
const [agentPda] = PublicKey.findProgramAddressSync(
  [Buffer.from('prova_agent'), operator.toBuffer()],
  PROVA_PROGRAM_ID
);

Action types

Type	Use for
`Transaction`	On-chain actions: swaps, transfers, LP operations.
`ToolCall`	The agent invoked a tool / external function.
`ModelInvocation`	An LLM call (model + prompt hash).
`Decision`	An autonomous decision with its rationale.
`ResourceAccess`	The agent read or wrote an external resource / API.
`PolicyCheck`	A policy evaluation with pass/fail result.
`Custom`	Anything else — bring your own schema.

Typed payloads with AttestationBuilder

import { AttestationBuilder } from 'prova-agent-sdk';

// Factory methods produce consistent, typed payloads per action type:
AttestationBuilder.transaction(txSignature);
AttestationBuilder.toolCall('jupiter_swap', { inputMint, outputMint });
AttestationBuilder.modelInvocation('claude-fable-5', promptHash);
AttestationBuilder.decision('rebalance', 'drift > 5%');
AttestationBuilder.resourceAccess('https://api.example.com', 'GET');
AttestationBuilder.policyCheck('max-slippage', 'pass');
AttestationBuilder.custom({ anything: true });

Storage model: events + indexer

Prova does not create one account per attestation. Storing every receipt in account state would cost rent per receipt and would not scale to thousands of actions per day. Instead, the program verifies the Ed25519 signature and emits an AttestationIssued Anchor event — the cryptographic commitment is permanently anchored in the transaction.

A WebSocket indexer captures these events with finalized commitment and projects them into Postgres for efficient querying (filters, pagination, stats) through the REST API. The database is a derived view, 100% reconstructible by re-scanning the chain — the chain remains the single source of truth.

Layer	Holds	Guarantees
On-chain (Solana)	Hash, signature, type, timestamp — inside the tx and its events.	Immutability, ordering, independent verification.
Off-chain (Postgres)	Indexed projection of the same events.	Fast queries. Reconstructible; never authoritative.

Privacy mode (Vanish)

With privacyMode: true, the receipt proves an action happened — signed, typed, timestamped — while the payload remains off-chain with the operator. To disclose selectively (e.g. to an auditor), share the payload: anyone can recompute the SHA-256 and match it against the on-chain hash.

Trust model

Prova never custodies keys or funds; all signing happens on your side.
Verification does not require Prova: the receipt is verifiable with any Solana RPC and standard tooling.
The program and SDKs are open source (Apache 2.0), so the whole pipeline is auditable.