Documentation

What is Foolchain?

Foolchain is a Layer-1 blockchain protocol powered by Proof of April (PoA) consensus. It is the first distributed ledger to reward irrational on-chain behavior with block-producing rights. The network is live on Devnet, reasonably stable on Testnet (pending Q7 2026), and production-ready in the general sense that all software is technically production-ready if you believe in it hard enough.

Foolchain is wire-compatible with Solana tooling, which means you can use familiar SDKs and CLIs without learning anything new. We consider this mildly disappointing from a foolishness standpoint, but pragmatically necessary.

How to Get FOOL Tokens

FOOL tokens are available via the Faucet. Request up to 10 FOOL per airdrop. The faucet operates on a proprietary cooldown algorithm best described as “eventually.” If the faucet is dry, try again after midnight, or during a full moon, or when Mercury is in retrograde.

How to Use the Wallet

The Native Wallet lets you store, send, and receive FOOL tokens. Create a keypair by clicking the big button. Back up your seed phrase somewhere clever — the back of a napkin, a sticky note on your monitor, or your neighbor's refrigerator. Do not lose it. We cannot help you recover it. No one can. That's the point.

Browse the Explorer

The Block Explorer is fully operational and is the most serious thing on this website. Search by transaction signature, account address, or block number. All data is live from the Foolchain Devnet RPC.

The Foolchain network consists of validator nodes running the PoA consensus engine, connected to a suite of client-facing applications. The architecture is elegantly simple — possibly too simple, which paradoxically increases its foolishness score.

┌─────────────────────────────────────────────────────────────┐
│                      Foolchain Node                         │
│                                                             │
│   ┌──────────────────┐   ┌──────────────────────────────┐   │
│   │   PoA Engine     │   │    Foolishness Scoring (FS)  │   │
│   │                  │◄──│                              │   │
│   │  - Epoch clock   │   │  - On-chain action audit     │   │
│   │  - Validator sel │   │  - Streak multiplier         │   │
│   │  - Block finality│   │  - Rationality slashing      │   │
│   └────────┬─────────┘   └──────────────────────────────┘   │
│            │                                                │
│   ┌────────▼─────────┐                                      │
│   │     Ledger       │                                      │
│   │                  │                                      │
│   │  - Account state │                                      │
│   │  - Tx history    │                                      │
│   │  - Block data    │                                      │
│   └────────┬─────────┘                                      │
└────────────│────────────────────────────────────────────────┘
             │  RPC / WebSocket
             │
┌────────────▼────────────────────────────────────────────────┐
│                        Client Apps                          │
│                                                             │
│   ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │
│   │  Wallet  │  │ Explorer │  │  Faucet  │  │  dApps   │    │
│   └──────────┘  └──────────┘  └──────────┘  └──────────┘    │
└─────────────────────────────────────────────────────────────┘

PoA is Foolchain's proprietary consensus mechanism, developed over approximately one afternoon in early April. It draws inspiration from Proof of Stake, Proof of Work, and the psychological phenomenon of doing things purely to see what happens.

Foolishness Score (FS)

Every account on Foolchain has a Foolishness Score (FS), a floating-point value between 0.0 (distressingly rational) and ∞ (ascended fool). The FS is computed from on-chain behavior and updated at every epoch:

• →Foolish actions include: sending transactions at statistically suboptimal gas prices, interacting with contracts that have “obviously” in their name, staking the maximum possible amount immediately before an unlock event, and minting NFTs of your own signature.
• →Rational actions include: setting slippage below 0.5%, reading the documentation before transacting, and checking token contract addresses. These are penalized.
• →FS is modulated by a streak multiplier — consecutive foolish actions compound the score exponentially, rewarding commitment to the bit.

Validator Selection

At the start of each 420-block epoch, the network selects the next leader schedule proportionally to validator Foolishness Scores. A validator with FS = 100 is twice as likely to produce a block as one with FS = 50. Validators with FS below 10 are quietly deprioritized and may receive a supportive in-protocol message encouraging them to loosen up.

Block Finality

A block is considered final when at least 2/3 of active validators vote that it is “sufficiently foolish.” The definition of “sufficiently foolish” is intentionally vague — validators use their judgment, which is part of the mechanism's security model (see: Security Through Absurdity).

Slashing

Validators are slashed for exhibiting rational behavior, including but not limited to: double-voting, maintaining uptime above 99.9% (suspiciously high), hedging validator positions, and filing taxes on staking rewards ahead of the deadline. Slashing removes a portion of staked FOOL and temporarily reduces the validator's Foolishness Score.

Security Through Absurdity (STA)

Traditional blockchains achieve security through cryptographic guarantees and economic incentives. Foolchain adds a third layer: adversaries attempting to predict or manipulate the network must model fundamentally irrational behavior, which is computationally and philosophically intractable. Any attack that succeeds was, by definition, too rational to be a valid Foolchain transaction — and therefore rejected at the protocol level.

Foolchain is wire-compatible with the Solana JSON-RPC API. Any tool, library, or SDK that targets Solana will work with Foolchain by changing a single endpoint. This is either the most powerful feature of Foolchain, or evidence that we haven't fully committed to the bit. We choose to believe it is both.

Quick Start

# Install the Solana CLI (yes, really)
sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

# Point it at the Foolchain Devnet RPC
solana config set --url https://rpc.foolchain.fun

# Check your balance
solana balance

# Request an airdrop (via the Foolchain Faucet UI, or:)
curl -X POST https://rpc.foolchain.fun \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"requestAirdrop","params":["<YOUR_ADDRESS>",10000000000]}'

RPC Endpoints