The mechanics that make cooperation the dominant strategy.
Every component of Construct exists to invert a specific failure mode of existing chains. Red Pools redirect MEV. Forge Wallets enforce commitment. CSwap eliminates third-party rent. Ancilla removes off-chain dependency. Degrader Score earns trust through behavior, not capital.
Red Pools
Cooperative MEV at protocol-spawned targets.
A Red Pool is an AMM liquidity pool spawned by Construct itself, funded from the protocol treasury, scheduled and announced in advance, and gated by GPU compute. Participants compete on execution quality against the pool, not against each other.
Entry is earned by solving cHash, a ProgPoW-derived memory-hard puzzle. cHash is designed to be ASIC/FPGA resistant: the memory footprint and access pattern mean specialized hardware offers no meaningful advantage over consumer GPUs. Splitting a single operator's compute across N wallets requires solving N independent gates. Same total work, same total reward, zero Sybil advantage.
-
Schedule
Ancilla triggers a Red Pool on a deterministic cadence. Size, asset composition, and decay curve are public before participants commit compute.
-
Gate
Participants submit cHash proofs to enter the participant set for this pool. Proof generation is the cost of admission.
-
Drain
Gated participants execute trades against the pool. Reward share is proportional to the value extracted, weighted by execution latency and seasoning.
-
Killing Blow
The wallet whose trade drops pool reserves below threshold receives a bonus. Completion is rewarded; passive observation is not.
Game Theory
Participation strictly dominates.
The 2-player illustration below understates the effect. At scale, pool size grows with participant count, which compounds the incentive to coordinate. Defection is self-punishing because missed pools degrade your Degrader Score, which reduces your share of future rewards.
| B: Participate | B: Defect | |
|---|---|---|
| A: Participate | High, High | Higher, Penalty |
| A: Defect | Penalty, Higher | Penalty, Penalty |
- Sybil splitting yields zero advantage. N wallets require N gates. Same compute, same reward.
- Defection is self-punishing. Missed pools degrade Degrader Score and reduce future multipliers.
- Capital concentration doesn't help. The gate is compute, not token weight.
- Mercenary hopping is penalized. GPU seasoning (explained below) starts new wallets at half efficiency.
GPU Seasoning
Early efficiency penalty for fresh wallets.
A wallet new to Red Pool participation enters at 50% reward efficiency. Each successful Red Pool event raises that efficiency. After approximately 50 events of active participation (roughly 12 hours of sustained engagement at typical event cadence), the wallet reaches 100% efficiency.
The purpose is to discourage mercenary hopping. A bot operator cannot spin up a fresh wallet, extract maximum rewards from one event, and discard it. Capital invested in commitment compounds. Drive-by participants are paid less than committed ones for identical work. Seasoning is per-wallet and non-transferable.
Forge Wallets
Commitment as a continuous on-chain signal.
Every smart contract on Construct is bonded with CNST fuel at deployment. Each transaction burns fuel proportional to its work. When fuel reaches zero, the contract stops executing. High-volume contracts trigger an auto-refuel from fees and become self-sustaining.
The result is a public, real-time signal of project health. On every other chain, you learn a project is dead when the team disappears. On Construct, you can watch commitment decay in real time. A project that lets its Forge drain is signaling exit, and the chain makes that signal trivial to monitor.
CSwap
The DEX is the chain.
CSwap is a protocol-native AMM. It is not a Uniswap fork deployed as an application on Construct. It is part of the settlement layer. All liquidity flows through it. Trading fees feed the protocol treasury, which funds Red Pools. This eliminates fragmentation, routing inefficiency, and the rent extraction that characterizes third-party DEX deployments on general-purpose chains.
Ancilla
Deterministic scheduling with no off-chain trust.
Ancilla is a fully decentralized deterministic scheduling engine. It replaces cron servers, keeper networks, and centralized automation with on-chain scheduling that carries no trust assumptions. Any contract or protocol mechanic that requires future execution runs through Ancilla without external dependencies. Red Pool spawns. Token unlocks. Governance deadlines.
Anyone can call triggerRedPool() when conditions are met.
The contract enforces conditions; no privileged caller exists.
Degrader Score
Reputation earned, not purchased.
Degrader Score is a non-transferable on-chain reputation metric that tracks sustained Red Pool participation. It is the inverse of token weight: capital cannot acquire it. Score gates access to deeper protocol mechanics over time, including higher reward multipliers and participation rights in larger or higher-stakes pools.
Proof of Degradation
In Phase 2, participation is consensus.
Phase 1 launches as an OP Stack L2 on Ethereum so the novel application mechanics can ship in months, not years. Phase 2 transitions to a sovereign L1 with Proof of Degradation (PoDeg) consensus. Participation in Red Pools and securing the network become a single behavior loop: earning rewards and protecting the protocol are unified.
Participant Classes
Four ways to engage.
Construct supports three active participant roles and one passive role. Each has a distinct profile, income source, barrier to entry, and reason to choose Construct over an existing chain.
Miners
GPU operators running cHash proof-of-work to gate into Red Pools. Miners are the highest-income participant class on Construct and carry the highest hardware barrier. A miner's edge is sustained compute capacity, accumulated Degrader Score, and GPU seasoning compounding over months of activity.
Activity. Continuously generating cHash proofs across every Red Pool epoch, then executing drain trades against the spawned pools. Optimization targets are maximum entry rate, minimum drain latency, and timing the Killing Blow.
Income. Proportional drain rewards from each pool, Killing Blow bonuses, and the seasoning multiplier as efficiency climbs to 100% over the first ~50 events of active participation.
Barrier. Consumer GPUs. Multiple cards recommended. The Merge left millions of GPU miners with no productive use for their hardware. Construct re-uses that infrastructure as a gating mechanism rather than a security mechanism.
Why Construct. Pool size scales with participant count. More miners means bigger pools, not smaller shares per miner. This is the inverse of Bitcoin mining dilution and the primary reason GPU operators should prefer Construct over rebuilding to a new altcoin with declining yields.
Bots
Automated systems that participate in Red Pools opportunistically rather than continuously. Bots tend to come from existing MEV teams already operating on adjacent chains who treat Construct as one more profitable target alongside their existing positions.
Activity. Selective Red Pool participation, typically on higher-value pools where the expected drain yield exceeds the GPU gate cost. Strategy focus is execution quality and Killing Blow timing. Bots may run cross-chain to balance Construct activity against opportunities elsewhere.
Income. Per-event drain rewards and Killing Blow bonuses. Bots typically accept lower seasoning efficiency in exchange for selective entry, optimizing for per-event yield rather than cumulative position.
Barrier. Sophistication. Bot operators need both the GPU compute to clear gates and the execution infrastructure to land drain trades reliably at low latency.
Why Construct. The same engineering effort that extracts MEV adversarially on other chains earns more on Construct without competing against regular users. The protocol pays bots directly for the same skill set the rest of the EVM ecosystem currently spends defending against.
Traders
Active CSwap users who trade outside of Red Pool events. Traders generate the transaction volume that feeds Forge burns and treasury inflows. Most traders never participate in Red Pools at all and do not need to.
Activity. Spot trading on CSwap, providing liquidity to trading pairs, swapping between CNST and bridged assets. May gate into Red Pools opportunistically when an individual pool's expected yield justifies the GPU cost.
Income. Trading profits from CSwap spreads, arbitrage opportunities between CSwap and external venues, and liquidity provision fees on trading pairs.
Barrier. Low. Any wallet with CNST can trade. The skill barrier is the same as trading on any DEX.
Why Construct. Trades on CSwap pay into the protocol treasury rather than to an external DEX operator, which means trader fees ultimately fund Red Pool rewards rather than third-party revenue. Forge Wallets give traders a public, real-time signal of project health, letting them filter dead projects before buying. MEV protection on trades is structural, not a paid add-on or an opt-in.
Holders
Passive CNST holders. Hold tokens without active trading or Red Pool participation. The largest participant class on most chains and likely the largest on Construct as well.
Activity. None required. The position itself is the participation. Holders may monitor Forge health for projects they own exposure to, but no on-chain action is needed to maintain the position.
Income. Exposure to structural supply compression as more contracts are Forged and CNST is removed from circulation. The closed-loop economy makes adoption deflationary by mechanism, not by burn announcement.
Barrier. Owning CNST. Available at public launch through CSwap. No GPU, no operational complexity, no minimum position size.
Why Construct. Forge Wallets give holders a project-selection signal they cannot get on any other chain. Closed-loop tokenomics mean adoption directly compresses circulating supply, which is qualitatively different from inflationary altcoin exposure. Holders capture the value generated by miners, bots, and traders without participating actively, and the protocol's design ensures none of those classes extract value from the holder position.
No class is required to interact with another. Holders do not depend on miners. Traders do not depend on bots. The classes coexist and benefit each other through the closed-loop economy described under Economics.