Skip to main content
Proteus charges a 7% platform fee on market volume. The fee is deducted from the total pool when winners claim their payouts, with 93% going to the winner.

​
Fee Calculation

uint256 public constant PLATFORM_FEE_BPS = 700;  // 7% (700 basis points)

function claimPayout(uint256 _submissionId) external nonReentrant {
    // ... validation ...
    
    uint256 totalPool = market.totalPool;
    uint256 fee = (totalPool * PLATFORM_FEE_BPS) / 10000;  // 7%
    uint256 payout = totalPool - fee;                       // 93%
    
    pendingFees[feeRecipient] += fee;
    
    (bool success, ) = submission.submitter.call{value: payout}("");
    // ...
}
Basis Points: 700 BPS = 7.00%. Basis points avoid floating-point arithmetic in Solidity.

​
Fee Distribution (Whitepaper Spec)

From the whitepaper Section 5.3, the 7% platform fee is intended to be split across five stakeholder groups:
RecipientShare of FeeShare of VolumePurpose
Genesis NFT Holders20.0%1.4%Early supporter rewards
Oracles28.6%2.0%Resolution verification
Market Creators14.3%1.0%Incentivize quality markets
Node Operators14.3%1.0%Infrastructure providers
Builder Pool28.6%2.0%Protocol development
TOTAL100%7.0%
v0 Alpha Status: The detailed fee distribution mechanism (splitting across 5 recipients) is not yet implemented in PredictionMarketV2. Currently, all fees accumulate to a single feeRecipient address. The whitepaper spec represents the intended mainnet design.

​
Current Implementation (v0 Alpha)

​
Single Fee Recipient

PredictionMarketV2.sol:61-129
address public feeRecipient;

constructor(address _feeRecipient) Ownable(msg.sender) {
    feeRecipient = _feeRecipient;
}

function setFeeRecipient(address _newRecipient) external onlyOwner {
    feeRecipient = _newRecipient;
}
In the testnet prototype:
  • All fees go to a single address (feeRecipient)
  • Owner can update the recipient address
  • No on-chain splitting yet

​
Pull-Based Fee Collection

Anti-Griefing Design

Fees accumulate in a mapping and must be withdrawn manually. This prevents malicious fee recipients from reverting transfers and blocking winner payouts.
PredictionMarketV2.sol:306-316
mapping(address => uint256) public pendingFees;

function withdrawFees() external nonReentrant {
    uint256 amount = pendingFees[msg.sender];
    if (amount == 0) revert NoFeesToWithdraw();
    
    pendingFees[msg.sender] = 0;
    
    (bool success, ) = msg.sender.call{value: amount}("");
    if (!success) revert TransferFailed();
    
    emit FeesWithdrawn(msg.sender, amount);
}
Flow:
  1. Winner calls claimPayout() → fee accumulates in pendingFees[feeRecipient]
  2. Fee recipient calls withdrawFees() → ETH transferred to recipient
This two-step process ensures winner payouts cannot be blocked by a malicious or broken fee recipient contract.

​
Stakeholder Roles (Mainnet Design)

​
1. Genesis NFT Holders (20% of fees)

Early Supporter Rewards

Share: 1.4% of total volumePurpose: Reward early adopters who minted Genesis NFTsImplementation: Fees distributed proportionally to NFT holders
The Genesis NFT collection is already deployed:
  • Contract: 0x1A5D4475881B93e876251303757E60E524286A24 (BASE Sepolia)
  • Supply: 60/100 minted and finalized
  • Features: On-chain SVG art

​
2. Oracles (28.6% of fees)

Resolution Verification

Share: 2.0% of total volumePurpose: Compensate oracles for fetching and verifying actual text from X APIPlanned: Multi-oracle consensus with commit-reveal scheme
  • Single EOA (contract owner) calls resolveMarket()
  • Centralized, no economic incentive
  • Critical risk: Owner can submit false actual text
From README.md:
X API Update (Feb 2026): X now offers pay-per-use API access for individual developers — no subscriptions, no monthly caps, just credit-based billing. This is a significant unlock for oracle resolution: each oracle node can independently fetch posts by ID, verify authorship, and confirm timestamps via the X API v2.

​
3. Market Creators (14.3% of fees)

Quality Market Incentive

Share: 1.0% of total volumePurpose: Reward users who create popular, high-volume marketsMechanism: Proportional to volume their created markets generate
Anyone can call createMarket(actorHandle, duration). The market creator receives a share of fees from all volume in that market.
Without a market creation cost, this could incentivize spam markets. Possible mitigations:
  • Minimum creation fee
  • Reputation system
  • Curator approval for featured markets
  • Fee share only activates above minimum volume threshold

​
4. Node Operators (14.3% of fees)

Infrastructure Providers

Share: 1.0% of total volumePurpose: Compensate RPC providers, indexers, and backend infrastructureScope: Railway hosting, BASE RPC, Redis, monitoring services
This category covers operational costs:
  • Backend hosting (Railway)
  • RPC provider fees (currently public RPC, planned Alchemy/QuickNode)
  • Redis caching
  • Monitoring and logging (planned Sentry)

​
5. Builder Pool (28.6% of fees)

Protocol Development

Share: 2.0% of total volumePurpose: Fund ongoing development, audits, and protocol improvementsGoverned: Could transition to DAO or multisig in the future
This is the largest fee share (tied with Oracles) because it funds:
  • Smart contract audits
  • Frontend development
  • Security improvements
  • Integration with Timepoint suite (TDF, Clockchain)

​
Special Case: Single Submission Refund

No Competition = No Fee

If a market ends with only 1 submission, the participant receives a full refund with no fee charged.
PredictionMarketV2.sol:280-301
function refundSingleSubmission(uint256 _marketId) external nonReentrant {
    Market storage market = markets[_marketId];
    
    // Validation checks...
    
    uint256[] storage subIds = marketSubmissions[_marketId];
    if (subIds.length != 1) revert NotSingleSubmission();
    
    Submission storage submission = submissions[subIds[0]];
    if (submission.claimed) revert AlreadyClaimed();
    
    submission.claimed = true;
    market.resolved = true;
    
    // Full refund - no fee taken
    (bool success, ) = submission.submitter.call{value: submission.amount}("");
    if (!success) revert TransferFailed();
    
    emit SingleSubmissionRefunded(_marketId, subIds[0], submission.submitter, submission.amount);
}
Rationale: It would be unfair to charge 7% when there was no actual competition. The single participant gets all their ETH back.
Minimum submissions: Markets require MIN_SUBMISSIONS = 2 to resolve normally. With only 1 submission, refundSingleSubmission() must be called instead of resolveMarket().

​
Comparison: Proteus vs Other Platforms

  • Fee: 7%
  • Winner Share: 93%
  • Structure: Winner-take-all
  • Fee Distribution: 5 stakeholder groups (planned)
  • Special Cases: Single submission = full refund
Proteus’s 7% fee is competitive with Kalshi and higher than Polymarket, but justified by:
  1. On-chain Levenshtein computation (expensive gas costs)
  2. Complex oracle resolution (multiple sources, X API costs)
  3. Novel market primitive (higher development costs)

​
Fee Economics

​
Volume Scenarios

RecipientAmount
Winner9.3 ETH (93%)
Platform Fee0.7 ETH (7%)
Fee Split (Planned):
  • Genesis NFT Holders: 0.14 ETH
  • Oracles: 0.20 ETH
  • Market Creator: 0.07 ETH
  • Node Operators: 0.07 ETH
  • Builder Pool: 0.20 ETH

​
Sustainability Analysis

From the whitepaper’s market sizing:
  • Binary prediction markets: $40B volume in 2025
  • Projected 2026: $222.5B notional volume
  • Sports betting TAM: $187B by 2030
If Proteus captures even 0.1% of binary market volume:
  • Volume: $222.5M annually
  • Platform fees (7%): $15.6M annually
  • Builder Pool share (28.6%): $4.5M annually
This exceeds the cost of:
  • Annual security audits ($100-200K)
  • Full-time development team ($500K-1M)
  • Infrastructure costs ($50-100K)

​
Implementation Roadmap

1

v0 Alpha (Current)

✅ Single feeRecipient address✅ Pull-based fee withdrawal✅ 7% fee calculation✅ Single submission refund logic
2

Pre-Mainnet

  • Implement 5-way fee splitting contract
  • Genesis NFT holder distribution mechanism
  • Market creator reward tracking
  • Oracle compensation tied to resolution
3

Mainnet

  • Multi-oracle consensus system
  • Slashing for dishonest oracles
  • Node operator registry
  • Builder Pool governance (DAO or multisig)

​
Security Considerations

Pull-based withdrawal prevents griefing: Fees accumulate in pendingFees mapping and must be withdrawn manually. This means a malicious or broken fee recipient cannot block winner payouts by reverting on transfer().
Anti-pattern (push):
// BAD: If feeRecipient.transfer() reverts, entire transaction fails
feeRecipient.transfer(fee);
winner.transfer(payout);
Best practice (pull):
// GOOD: Accumulate fees separately, winner payout always succeeds
pendingFees[feeRecipient] += fee;
winner.call{value: payout}("");
This ensures winners can always claim, even if fee collection temporarily fails.

​
Reentrancy Protection

All payout functions use nonReentrant modifier: 
function claimPayout(uint256 _submissionId) external nonReentrant {
    // ...
}

function withdrawFees() external nonReentrant {
    // ...
}
This prevents reentrancy attacks during ETH transfers.

​
Key Takeaways

7% Platform Fee

93% to winner, 7% to platform

5 Stakeholder Groups

Genesis holders, oracles, creators, nodes, builders

Pull-Based Withdrawal

Prevents griefing attacks

No Fee for Single Entry

Full refund if no competition

Competitive Rate

Comparable to Kalshi, justified by novel mechanics

Reentrancy Protected

Safe ETH transfers

​
Further Reading

Market Lifecycle

See when fees are collected during market lifecycle

Contract Reference

Full PredictionMarketV2 documentation
Source: Fee structure from WHITEPAPER.md Section 5.3 and PredictionMarketV2.sol implementation.The 5-way fee split is the intended mainnet design. The v0 alpha currently uses a single fee recipient address.

Build docs developers (and LLMs) love

Get started for freeTalk to us