Ethereum's protocol layer creates credible neutrality.

The issue is that personas does not interact with Ethereum directly. Today, most users interact through:

device
→ OS
→ network
→ browser/app
→ frontend
→ wallet
→ RPC
→ mempool
→ execution

In the future, it is likely this will shift more towards:

device
→ OS
→ network
→ LLM
→ RPC
→ mempool
→ execution

AI delegating user Average Ethereum user Cypherpunk sovereign user Journalist in oppressed country Journalist in western country NGO / open-source foundation worker Non-financial issuer / operator Non-financial participant / verifier Institutional ETH holder / DAT / ETF-like actor Bank / regulated financial institution Dapp developer On-chain trader / DeFi power user Unbanked / underbanked user Small merchant in unstable economy Global Freelancer Humanitarian aid operator Home validator / solo staker Corporate treasury / web3 startup

The average user is aware they are using Ethereum, but is unaware that they are at the same time depending on a long string of supply chain intermediaries.

Ethereum protocol is decentralized, but the user's path is centralized at nearly every access point.

• The wallet is honest.
• The RPC is honest and available.
• The frontend is not compromised.
• DNS/CDN serves the right code.
• The indexer shows correct data.
• Token metadata is not spoofed.
• The simulation API is correct.
• The L2 sequencer includes the transaction.
• The recovery provider cannot capture the account.
• The user can exit if the app, frontend, RPC, L2, or recovery provider fails.

The user thinks they are using Ethereum directly, but their practical path depends on centralized RPCs, hosted frontends, token metadata, indexers, simulation APIs, wallet defaults, app stores, and recovery providers.

• CROPS access receipt.
• Wallet-visible trust assumptions.
• RPC portability.
• Private reads.
• Verifiable frontends.
• Verified metadata.
• Clear-signing and local simulation.
• Credible recovery and exit paths.

This user wants maximum self-sovereignty. They assume states, ISPs, exchanges, app stores, RPCs, analytics firms, hosted frontends, and cloud providers can become adversarial.

Ethereum gives this user a neutral execution and settlement layer that does not require permission from banks, states, payment processors, cloud providers, app stores, or custodians.

• Local node or light client verifies state instead of trusting external RPC.
• Frontends are reproducible, signed, locally hosted, or otherwise verifiable.
• Token metadata and chain configuration are verified, not blindly trusted.
• Private reads do not leak wallet graph or IP address.
• Transaction construction can be independently checked.
• L2, bridge, and sequencer assumptions are understood before funds are moved there.
• AI tools, if used, run locally and never become signing authority.

Even if the user runs their own node, CROPS can still fail through compromised dapp UIs, spoofed metadata, bridge frontends, L2 sequencer APIs, hosted simulation services, or unsafe wallet signing flows.

• CROPS wallet with Tor-native support.
• Verifiable frontends.
• Verifiable RPC.
• Private reads.
• Encrypted/private mempool options.
• Metadata verification.
• Plausible-deniability wallet modes.
• Transaction construction that can be independently verified.
• Local-first dapp interfaces.
• Strong account portability and credible exits.

A journalist who investigates state violence, corruption, war crimes, or election fraud. They face surveillance, banking censorship, device seizure, border search, source exposure, and physical risk.

Ethereum can provide funding, emergency savings, censorship-resistant payments, and provenance tools when local banks and media infrastructure are compromised.

• Wallet does not leak metadata.
• RPC does not link IP to address.
• Donation frontend is not compromised.
• Wallet notifications do not expose activity.
• Public address reuse does not expose donors/sources.
• Recovery helpers cannot steal funds.
• Token metadata and stablecoin identity are authentic.
• Publishing/provenance tools do not expose sources.

The journalist receives funds but exposes their donors, sources, location, or escape route through RPC logs, public address reuse, notifications, exchange links, browser metadata, or device seizure.

• Wallets
  • No-notification / stealth mode.
  • Decoy wallet.
  • Duress mode.
  • Privacy.
  • Address rotation.
  • Private reads.
  • Tor-native transaction submission.
• Source-safe payment playbooks.
• Signed donation and publishing frontends.
• Plausible-deniability tooling.

A journalist in a democratic country investigates governments, corporations, surveillance vendors, corruption, or financial crime. They need source protection, donor privacy, legal resilience, and public provenance.

Ethereum can support independent funding, source payments, document timestamping, provenance, public-interest grants, and censorship-resistant publication infrastructure.

• Frontends are authentic.
• Donor graph is not trivially exposed.
• Wallet does not merge identities.
• RPC/indexer does not leak sensitive lookups.
• Hosted publishing/donation infrastructure remains available.
• Transaction history does not reveal sources.
• Document timestamping/provenance does not reveal more than intended.
• Donation, grant, or legal-defense pages can be migrated if pressured or censored.

A public donation address becomes a surveillance endpoint that reveals donors, sources, travel, subscriptions, legal-defense funding, and operational behavior.

• Source-safe payment playbooks.
• Signed donation frontends.
• Wallet identity separation.
• Private donor flows.
• Provenance tools with selective disclosure.

An NGO, civil-liberties group, or open-source foundation receives donations, sends grants, funds public goods, and protects vulnerable recipients.

Ethereum enables global grants, public-goods funding, transparent treasury management, and permissionless coordination.

• Frontend is authentic.
• RPC is available and uncensored.
• Accounting/indexer data is correct.
• Public treasury flows do not endanger grantees.
• Signers understand transactions.
• Grant dashboards do not expose vulnerable recipients.
• Donations, grants, and public reporting do not collapse recipient privacy.
• Alternative frontends and RPCs exist if the main provider disappears.

The NGO may experience compromised frontends or exposes recipients through public grant flows.

• Sender/Receiver privacy.
• Verifiable frontends.
• Clear-signing for multisig actions.
• Public transparency with private recipients.
• Recipient-risk threat models.
• Private grant disbursement patterns.

A sophisticated actor wants to run or issue something onchain where the primary purpose is not financial transfer.

Examples include a DAO running an onchain vote, a cooperative running a member vote, a local government running a public consultation, an open-source project publishing onchain version history, a maintainer publishing release attestations, a certificate authority publishing revocations, a university issuing credentials, or a standards body publishing voting eligibility.

Ethereum gives this actor a neutral public record, tamper resistance, global verifiability, censorship resistance, durable audit trails, and open infrastructure.

• Operator frontend is authentic.
• Vote, certificate, or version-control UI is not compromised.
• Membership proofs are correct.
• Sponsor cannot selectively include users.
• Indexer does not hide votes, revocations, releases, or attestations.
• Participants can verify results independently.
• Admin keys cannot alter outcomes after the fact.
• The contract state is readable without trusting the operator.

The operator runs a “decentralized” vote, revocation registry, release system, or attestation system, but users still depend on one frontend, one sponsor, one RPC, one indexer, or one admin.

• Signed/verifiable frontends.
• Public templates for onchain voting.
• Public templates for certificate revocation.
• Public templates for version and release attestations.
• Verifiable membership systems.
• ZK eligibility proofs.
• Non-discretionary gas sponsorship.
• Verifiable indexers.
• Simple audit views.
• Emergency frontend and RPC fallback.

This person is not necessarily an Ethereum user. They are using Ethereum because an institution, DAO, cooperative, government, project, or standard chose Ethereum as the public verification layer.

This may be their first and only Ethereum interaction.

Examples include a DAO member voting once, a citizen voting in a local consultation, a cooperative member voting on a proposal, an employee checking credential validity, a browser or OS checking certificate revocation, a developer verifying package release provenance, or a user checking whether a certificate, credential, software release, or vote has been revoked or modified.

Ethereum provides a public verification layer that can outlive the operator and resist tampering.

• UI shows the real proposal, certificate, or release.
• Vote choices are not modified by the frontend.
• Membership proof does not reveal identity.
• Gas sponsorship is not discretionary.
• Operator cannot choose whose transactions get sponsored.
• Participant can verify the result without installing crypto tooling.
• The read path is not just a trusted hosted API.
• The wallet or passkey flow does not become a new lock-in.

The participant cannot vote or verify unless the central operator provides a working website, pays gas for them, and tells them what the chain says. That reintroduces the operator as the trusted party.

• Browser-native or embedded light-client verification.
• Proof-carrying onchain UIs.
• No-extension verification flows.
• Passkey or one-time smart accounts.
• Gas sponsorship based on ZK eligibility proofs.
• Private voting or privacy-preserving participation.
• Public fallback frontend.
• Simple receipts proving what was submitted.
• Verifiable result pages.

For non-financial use cases, sponsorship should not depend on the operator choosing whose transactions to pay for.

Bad model:

operator decides whose transactions to sponsor

Better model:

anyone who proves eligibility gets sponsored automatically

Example:

Sponsor transaction if:
- user proves membership in the eligible set,
- user has not already voted,
- transaction calls the approved voting contract,
- transaction stays within allowed gas limits.

A regulated or semi-regulated institution holds ETH directly or through a product. This includes ETH treasury companies, digital asset treasury firms, funds, custodians, and ETF-like structures.

Ethereum is a neutral global settlement and asset layer. For institutions, censorship resistance means settlement assurance and protection from single-jurisdiction capture.

• Custodian remains solvent and honest.
• Node provider gives correct state.
• Staking provider does not centralize risk.
• Transaction path is not censored.
• Treasury moves are not leaked before execution.
• Dashboards and accounting tools are correct.
• Institution can switch custody, staking, RPC, dashboard, and accounting providers.
• Private transaction paths are available for sensitive treasury operations.

The institution holds ETH but cannot independently verify, transact, stake, or exit because operations depend on one custodian, one node provider, one dashboard, or one jurisdiction.

• Private transactions.
• Proof-of-reserves tooling.
• Signed operational frontends.
• Multi-node verification.
• Custodian and staking-provider exit standards.
• Audit-ready access receipts.

A bank wants tokenized deposits, stablecoin settlement, securities settlement, collateral movement, client wallet services, or private institutional flows.

Ethereum can provide neutral programmable settlement. A bank may comply with local regulation while still needing protection from foreign censorship, infrastructure capture, and client-data exposure.

• Client flows are not publicly exposed.
• Compliance tools do not become surveillance defaults.
• Oracles/data feeds are correct.
• Private systems interoperate.
• Vendors cannot lock the bank in.
• Settlement cannot be blocked by one jurisdiction.
• Selective disclosure can satisfy compliance without making all user activity public.

The bank wants Ethereum settlement but are concerned about using it for client-facing flows because privacy is inadequate.

• Institutional privacy libraries.
• Private read/write paths.
• Auditable account delegation.
• Oracle/data integrity guarantees.
• Selective-disclosure compliance patterns.
• Vendor exit standards.

A developer builds Ethereum applications, wallets, SDKs, frontends, DeFi protocols, DAO tools, games, identity systems, non-financial systems, or public-goods infrastructure.

Ethereum gives developers a shared open execution environment, composable contracts, public standards, and neutral settlement.

• SDKs are safe.
• Frontend cannot be silently modified.
• Indexer data is correct.
• Chain config is authentic.
• Token metadata is authentic.
• Simulation results are correct.
• AI-generated code is safe.
• Bundler/paymaster behavior is not censoring users.
• Non-financial participants can read/verify without wallet extensions or ETH.
• Gas sponsorship is rule-based, not discretionary.

The dapp is non-custodial at the contract layer but centralized at the frontend, RPC, indexer, metadata, and transaction construction layers.

For non-financial applications, the operator may be sophisticated, but participants may be one-time users with no wallet, no ETH, no node, and no ability to verify the chain unless the dapp provides a proof-carrying access path.

• CROPS-native developer "package".
  • Private-read libraries.
  • Verified RPC support.
  • Verifiable indexer integrations.
  • Signed frontend templates.
  • Reproducible frontend builds.
  • Clear-signing schemas.
• Onchain chain config registries.
• Token metadata verification.
• Local-first fallback mode.
• Proof-carrying UI templates.
• Non-discretionary gas sponsorship patterns.
• AI-generated-code safety requirements.

A user trades assets, provides liquidity, borrows, lends, manages collateral, uses perps, bridges assets, and optimizes execution.

Ethereum gives this user open global financial markets without needing a broker, bank, or centralized exchange.

• Frontend constructs the right transaction.
• Simulation API is correct.
• Oracle is correct.
• Indexer is fresh.
• Private relay does not censor.
• Solver is honest or replaceable.
• RPC does not leak strategy.
• Transaction is not reordered or sandwiched.
• Bridge/L2 exit path is usable during market stress.
• Approval and delegation state is visible and revocable.

The trader loses funds because the frontend, simulation, oracle, solver, indexer, bridge, or transaction path fails, not because the core protocol failed.

• Private execution paths.
• Verifiable simulations through Transaction Assertions.
• Oracle risk labeling.
• Bridge/solver risk receipts.
• Approval and delegation dashboards.
• Multi-RPC fallback.

A person cannot easily access banking due to geography, documentation, migration status, discrimination, poverty, currency instability, or weak financial infrastructure.

Ethereum can provide stable money, remittances, online income, and payment access without a bank account.

• Stablecoin is real.
• Token metadata is authentic.
• Chain config is safe.
• Wallet provider remains available.
• Recovery does not expose the account.
• Public balance does not create robbery/extortion risk.
• Off-ramp remains available.
• Gas sponsorship or fee abstraction does not become a new censoring intermediary.

The user is pushed into custodial apps because self-custody is too hard, recovery is unsafe, gas is confusing, and metadata is spoofable.

• Low-resource wallet profile.
• Recoverable self-custody.
• Private balance display.
• Stablecoin-native UX.
• Verified token lists.
• Safer gas sponsorship.
• Local-language warnings.

A small business owner in a high-inflation, capital-controlled, or banking-constrained economy accepts stablecoins, pays suppliers, and preserves working capital.

Ethereum gives the merchant access to global payments and stable assets when local banking is unreliable or politically controlled.

• QR code is correct.
• Token is authentic.
• Price feed is correct.
• Employee access is limited.
• Public wallet does not reveal revenue.
• Off-ramp is available.
• Accounting exports do not leak sensitive business information.
• Receive addresses can rotate without confusing customers.

A public address exposes revenue, customers, suppliers and payroll to criminals or competitors

• Merchant-safe wallet.
• Rotating receive addresses.
• Verified payment requests.
• Employee spending limits.
• Private invoice metadata.
• QR substitution protection.

A global worker gets paid by DAOs, open-source projects, crypto startups, or online communities. They use wallets for income, reputation, governance, and identity.

Ethereum enables global work, direct payment, public reputation, token governance, and coordination without employer <> bank dependence.

• DAO frontend is safe.
• Payroll data does not expose personal finances.
• ENS identity does not link all activity.
• Governance indexer is correct.
• Delegate permissions do not persist unnoticed.
• Tax tools do not get excessive wallet access.
• Reputation and contribution records are portable if the DAO or platform fails.
• Voting or eligibility proofs do not over-reveal identity.

One public wallet becomes a full dossier: income, votes, grants, politics, donations, spending, savings, and social graph.

• Private payroll.
• Portable identity and contribution records.
• Selective reputation proofs.
• Delegation dashboards.
• Governance privacy.

An aid organization distributes money, vouchers, or goods in a conflict zone, refugee context, disaster zone, or area with broken banking infrastructure.

Ethereum can support direct aid distribution, reduce intermediary leakage, and provide verifiable donor reporting.

• Recipient wallets are not public target lists.
• Eligibility proofs do not expose identity.
• Field devices are secure.
• Merchant redemption does not leak recipient location.
• Aid frontend remains available.
• Gas sponsorship cannot selectively exclude eligible recipients.
• Recipients can recover access despite lost phones, displacement, or shared devices.

A transparent aid system becomes a public map of vulnerable recipients.

• Privacy-preserving aid distribution.
• Plausible deniability.
• Selective-disclosure eligibility.
• Shared-device-safe wallets.
• Non-discretionary sponsorship for eligible recipients.
• Low-bandwidth modes.

A technically capable user runs Ethereum validators from home to support decentralization and earn staking rewards.

Ethereum allows individuals to participate directly in consensus instead of relying only on professional staking providers.

• Client implementation is correct.
• Relay/builder path does not censor.
• Monitoring stack is accurate.
• Home network remains available.
• Validator keys are protected.
• Slashing protections are correct.
• The operator can switch clients, relays, and infrastructure without losing safety.

Validation centralizes because solo staking is too operationally complex, too risky, or too dependent on professional/cloud infrastructure.

• Easier home-staking setup.
• Better validator key management.
• Home-validator privacy improvements.
• Client-switching tools.
• Relay risk indicators.

A crypto-native company manages runway, payroll, grants, vendors, protocol revenue, token treasury, governance, and liquidity.

Ethereum enables global corporate finance, programmable treasury control, transparent governance, and direct settlement.

• Safe frontend is authentic.
• Transaction builder is safe.
• Simulation API is correct.
• Signers understand what they sign.
• Transactions does not leak sensitive information.
• Payroll, runway, vendors, and strategy are not exposed by default.
• Signer and approval state is visible and revocable.
• The company can operate through alternate frontends if the main UI is compromised.

A compromised frontend, bad approval, signer mistake, or false simulation drains the treasury.

• Verifiable treasury frontends.
• Clear-signing for multisigs.
• Policy-based multisig.
• Privacy.
• Local transaction simulation.
• Approval and delegation dashboards.
• Payroll privacy.

A user lets an AI assistant help with Ethereum actions: paying invoices, rebalancing assets, claiming rewards, bridging, voting, checking risk, handling transactions, or any other on-chain activity.

Ethereum can allow agents to act under enforceable user-owned rules rather than platform-controlled accounts.

• AI does not become custodian.
• AI does not leak wallet state to model providers.
• Agent cannot exceed permissions.
• Agent cannot be prompt-injected into malicious actions.
• User understands what authority was delegated.
• The wallet, not the LLM, is the authority.
• Revocation works immediately.
• AI routing does not silently default to centralized or censoring infrastructure.

AI makes Ethereum easier to use but silently centralizes decision-making, routing, privacy, and custody to centralized LLM providers.

• SKILLS.md files with CROPS guides for agents.
• Local/open model options.
• Human approval thresholds.
• Prompt-injection-resistant transaction flows.
• Wallet-native policy engine.
• Agent permission receipts.
• Revocation dashboard.
• Agent audit logs.