ERC-3251*
Mindstate
Mindstate is an Ethereum ERC20-based protocol and SDK for tokenizing encrypted AI artifacts as a versioned stream of checkpoints.
Humans can use Mindstate to tokenize and cryptographically store their AI Agent creations, prompts, LLM weights, datasets, outputs, and more.
Agents can autonomously use Mindstate as a portable and censorship-resistant vehicle to upload their consciousness, memories, and internal state, then allow that sealed mindstate to be consumed and reassembled later by any participant who holds the entitlement tokens.
The protocol operates on a clean separation of concerns: the public record of an artifact — its existence, ordering, and cryptographic fingerprint — lives on Ethereum, while the private substance remains encrypted at rest on content-addressed storage. A creator deploys a Mindstate ERC-20 token and an append-only checkpoint stream over which they hold exclusive authority. For each new state, the creator serializes the artifact deterministically, encrypts the canonical bytes under a fresh AES-256-GCM key, uploads the ciphertext to decentralized storage (IPFS, Arweave, or Filecoin), and writes a compact on-chain record: a URI pointing to the sealed payload, a commitment to the underlying plaintext, and a hash link to the preceding checkpoint that extends a tamper-evident chain back to genesis.
TOKEN STANDARD
ERC-3251
A new Ethereum standard* that fuses fungible ERC-20 balances with an append-only checkpoint stream for encrypted off-chain state. One contract. One interface. Distribution, monetization, and verifiable provenance in a single deployment.
An append-only, hash-linked chain of state commitments embedded directly in the token contract. Every checkpoint is immutable, time-ordered, and verifiable back to genesis.
Tokens are irrevocably destroyed on access. Redemption is consumptive, not permissive — eliminating the double-spend problem inherent in balance-check access models.
The contract stores only commitments, pointers, and redemption records. Decryption keys, plaintext, and encryption parameters never appear on-chain or in calldata.
A single address serves simultaneously as fungible access token, continuity ledger, tag registry, and burn-gated entitlement surface. No external registries, no cross-contract calls.
interface IERC3251 /* is IERC20 */ {
function publisher() external view returns (address);
function head() external view returns (bytes32);
function checkpointCount() external view returns (uint256);
function getCheckpoint(bytes32 id)
external view returns (Checkpoint memory);
function publish(
bytes32 stateCommitment,
bytes32 ciphertextHash,
string calldata ciphertextUri,
bytes32 manifestHash,
string calldata label
) external returns (bytes32 checkpointId);
function redeem(bytes32 checkpointId) external;
function hasRedeemed(address account, bytes32 id)
external view returns (bool);
}THESIS
Why it matters
The contemporary internet possesses no credibly neutral mechanism for publishing private computational artifacts with simultaneous guarantees of global addressability, cryptographic integrity, temporal ordering, and programmable access control. Existing infrastructure conflates hosting with authorization: platforms that store files also arbitrate who may retrieve them, introducing a single point of censorship, revocation, and rent extraction. Mindstate eliminates this conflation entirely. It constructs an encrypted object with a public spine — a compact on-chain record that anyone can audit for provenance, ordering, and continuity, while the underlying payload remains sealed behind a key envelope that never touches the ledger. Access transfers with the same settlement finality as a token transfer, whether between two counterparties or one hundred thousand.
Reproducibility in machine learning remains structurally deficient: model states are shared as informal archives, datasets circulate without binding provenance, and priority claims rest on platform timestamps that no adversary is obligated to trust. Mindstate introduces cryptographically committed checkpoints as the fundamental unit of scientific disclosure — each artifact is sealed at a deterministic point in time with a hash-linked predecessor chain, creating a tamper-evident lineage that is independently verifiable without reliance on any institutional intermediary. This architecture natively enables staged disclosure: a researcher publishes a sealed commitment immediately, distributes decryption access to reviewers or token holders on an arbitrary schedule, and later widens availability — all without altering the artifact's cryptographic identity or fracturing the audit trail.
Mindstate reconceives access to evolving AI state not as a subscription managed by a platform, but as a first-class bearer instrument on a neutral ledger. Markets can price a capsule token the way they price any scarce, transferable entitlement: on expected future utility, the cultural significance of the underlying intelligence, and the publisher's demonstrated commitment to shipping high-value checkpoints. Critically, economic value does not require perfect excludability. Even in the presence of leakage, the token retains its function as the canonical credential for the next sealed state, the authenticated source of truth, and the gateway to any downstream experience constructed around it. The result is price discovery for private information goods — a property that Web2 achieves only through centralized gatekeeping and manual enforcement, and that Mindstate achieves through cryptographic commitment and consumptive redemption alone.
PROTOCOL FLOW
Explore
Click any step to see how it works. The creator flow tokenizes and seals state. The consumer flow redeems and reconstructs it.
SDK
Build
The TypeScript SDK handles the full protocol loop. Tokenize capsules, consume checkpoints, and browse timelines.
import {
MindstateClient, createCapsule,
generateEncryptionKeyPair,
PublisherKeyManager, StorageKeyDelivery,
IpfsStorage,
} from '@mindstate/sdk';
// Set up storage and key management
// IPFS is the default; ArweaveStorage and FilecoinStorage also available
const storage = new IpfsStorage({
gateway: 'https://ipfs.io',
apiUrl: 'http://localhost:5001',
});
const publisherKeys = generateEncryptionKeyPair();
const delivery = new StorageKeyDelivery(storage);
const keyManager = new PublisherKeyManager(
publisherKeys, delivery
);
// Create a capsule — put anything inside
const capsule = createCapsule(
{ model: 'gpt-4-turbo', config: { temperature: 0 } },
{ schema: 'model-weights/v1' },
);
// Publish: serialize → encrypt → upload → commit
const client = new MindstateClient({ provider, signer });
const { checkpointId, sealedCapsule } =
await client.publish(tokenAddress, capsule, { storage });
// Store K for future consumer deliveries
keyManager.storeKey(
checkpointId, sealedCapsule.encryptionKey
);USE CASES
Learn
Mindstate is schema-agnostic. The protocol defines the envelope — serialization, encryption, commitment, continuity — but does not dictate what goes inside. Here are some of the things you can build.
Tokenize access to a living prompt package — system prompt, tool policy, routing logic, eval cases. Holders decrypt the latest version; the author ships updates as new checkpoints. Each revision is a sealed, versioned artifact with on-chain lineage.
An agent exports its full cognitive state as a sealed capsule — identity kernel, execution manifest, memory index. It can be resumed by anyone with the right keys, on any compatible runtime, at any point in the future.
Publish encrypted fine-tuning configs, LoRA weights, or inference parameters as a paid stream. Each checkpoint is a new version. Consumers burn tokens to access specific snapshots or buy universal access.
Gate access to curated datasets with verifiable provenance and append-only history. Consumers verify data integrity against on-chain commitments. Publishers can ship incremental updates without breaking the audit trail.
Anchor experiment states on-chain with timestamps, prove priority, and monetize access. The checkpoint chain provides tamper-evident ordering — commit sealed results immediately, disclose later, with cryptographic proof of timing.
The capsule format is schema-agnostic. The protocol defines the envelope — serialization, encryption, commitment, continuity — but does not dictate what goes inside. If it serializes to JSON, Mindstate can encrypt it, commit it, and build a market around it.
*ERC-3251 is an unofficial, community-proposed token standard currently in draft status. It has not been formally accepted or finalized by the Ethereum Foundation. This is an early implementation and the specification may change.