TL;DR
I built an open-source, gas-optimized prediction market smart contract in Solidity using Foundry. It features pot-based binary markets, proportional payout distribution, admin resolution, and comprehensive security patterns. 95 tests, 98%+ coverage, deployable to Ethereum, Base, Polygon, Arbitrum, Optimism, and BSC.
GitHub: https://github.com/SivaramPg/evm-simple-prediction-market-contract
Table of Contents
- Introduction
- Architecture Overview
- Smart Contract Design
- Payout Formula Deep Dive
- Security Patterns Implemented
- Gas Optimization Techniques
- Testing with Foundry
- Multi-Chain Deployment
- Conclusion
Introduction
Prediction markets are fascinating DeFi primitives that allow users to bet on the outcome of future events. Unlike AMM-based prediction markets (like Polymarket's CLAMM), this implementation uses a simpler pot-based parimutuel system - perfect for learning smart contract development or bootstrapping your own prediction market protocol.
What We're Building
Binary prediction markets (YES/NO outcomes)
Pot-based parimutuel betting (proportional payouts)
ERC20 stablecoin integration (USDC, USDT, DAI)
Admin-controlled resolution (oracle-free for simplicity)
Multi-chain deployment (6 EVM chains)
Tech Stack
Solidity ^0.8.20 - Smart contract language
Foundry - Development framework (forge, cast, anvil)
OpenZeppelin patterns - Security best practices
Slither/Mythril compatible - Static analysis ready
Architecture Overview
System Components
┌─────────────────────────────────────────────────────────────┐
│ PredictionMarket.sol │
├─────────────────────────────────────────────────────────────┤
│ Config │ Market[] │ Positions │
│ - admin │ - id │ - yesBet │
│ - stablecoin │ - question │ - noBet │
│ - feeRecipient │ - resolutionTime │ - claimed │
│ - maxFeePercentage │ - state │ │
│ - paused │ - yesPool / noPool │ │
│ │ - winningOutcome │ │
│ │ - configSnapshot │ │
├─────────────────────────────────────────────────────────────┤
│ Functions │
│ - createMarket() - placeBet() - claimWinnings() │
│ - resolveMarket() - cancelMarket() - claimMultiple() │
│ - pause/unpause() - updateConfig() │
└─────────────────────────────────────────────────────────────┘
State Machine
Markets follow a strict state machine:
┌──────────┐
│ Active │ ←── createMarket()
└────┬─────┘
│
│ (resolution time reached)
▼
┌─────────────────────────────┐
│ │
▼ ▼
┌──────────┐ ┌───────────┐
│ Resolved │ │ Cancelled │
└──────────┘ └───────────┘
│ │
└──────────┬──────────────────┘
▼
claimWinnings()
Smart Contract Design
Storage Layout
Efficient storage packing is crucial for gas optimization:
struct Config {
address admin; // slot 0 (20 bytes)
bool paused; // slot 0 (1 byte) - packed!
address stablecoin; // slot 1
uint8 stablecoinDecimals;// slot 1 - packed!
address feeRecipient; // slot 2
uint16 maxFeePercentage; // slot 2 - packed!
uint256 marketCounter; // slot 3
}
struct Market {
uint256 id;
string question; // dynamic, separate slot
uint256 resolutionTime;
MarketState state; // uint8
Outcome winningOutcome; // uint8
uint256 yesPool;
uint256 noPool;
uint256 creationFee;
address creator;
ConfigSnapshot configSnapshot; // frozen at creation
}
struct UserPosition {
uint256 yesBet;
uint256 noBet;
bool claimed;
}
Key Design Decisions
1. Config Snapshot at Market Creation
function createMarket(...) external returns (uint256) {
// Snapshot config at creation time
market.configSnapshot = ConfigSnapshot({
feeRecipient: config.feeRecipient,
maxFeePercentage: config.maxFeePercentage
});
}
Why? If admin changes fee settings mid-market, existing markets retain their original terms. This prevents rug-pull scenarios where admins could change fees after users have committed funds.
2. No Opposition = Must Cancel
function resolveMarket(uint256 marketId, Outcome outcome) external onlyAdmin {
require(market.yesPool > 0 && market.noPool > 0, NoOpposition());
// ...
}
Why? If only one side has bets, there's no losing pool to distribute. The market must be cancelled with full refunds.
3. Manual Admin Resolution
We chose manual resolution over oracles for simplicity. For production, consider integrating:
Chainlink Functions for API-based resolution
UMA Optimistic Oracle for dispute-based resolution
Reality.eth for crowd-sourced resolution
Payout Formula Deep Dive
The Parimutuel Formula
payout = user_bet + (user_bet / winning_pool) * losing_pool
Or equivalently:
payout = user_bet * (1 + losing_pool / winning_pool)
payout = user_bet * total_pool / winning_pool
Implementation
function _calculatePayout(
uint256 marketId,
address user
) internal view returns (uint256) {
Market storage market = markets[marketId];
UserPosition storage position = userPositions[marketId][user];
if (market.state == MarketState.Cancelled) {
// Full refund on cancellation
return position.yesBet + position.noBet;
}
// Resolved market
uint256 winningPool;
uint256 losingPool;
uint256 userWinningBet;
if (market.winningOutcome == Outcome.Yes) {
winningPool = market.yesPool;
losingPool = market.noPool;
userWinningBet = position.yesBet;
} else {
winningPool = market.noPool;
losingPool = market.yesPool;
userWinningBet = position.noBet;
}
if (userWinningBet == 0) return 0;
// payout = userBet + (userBet * losingPool) / winningPool
uint256 winnings = (userWinningBet * losingPool) / winningPool;
return userWinningBet + winnings;
}
Example Scenarios
Scenario 1: Equal Pools
- YES pool: 100 USDC, NO pool: 100 USDC
- Alice bet 100 USDC on YES, YES wins
- Payout: 100 + (100 * 100) / 100 = 200 USDC (2x return)
Scenario 2: Unequal Pools
- YES pool: 100 USDC, NO pool: 400 USDC
- Alice bet 100 USDC on YES, YES wins
- Payout: 100 + (100 * 400) / 100 = 500 USDC (5x return)
Scenario 3: Multiple Winners
- YES pool: 200 USDC (Alice: 100, Bob: 100), NO pool: 100 USDC
- YES wins
- Alice: 100 + (100 * 100) / 200 = 150 USDC
- Bob: 100 + (100 * 100) / 200 = 150 USDC
Security Patterns Implemented
1. Checks-Effects-Interactions (CEI)
function claimWinnings(uint256 marketId) external {
// CHECKS
require(market.state != MarketState.Active, MarketNotFinalized());
require(!position.claimed, AlreadyClaimed());
require(position.yesBet > 0 || position.noBet > 0, NoPosition());
// EFFECTS
position.claimed = true;
uint256 payout = _calculatePayout(marketId, msg.sender);
// INTERACTIONS
if (payout > 0) {
IERC20(config.stablecoin).transfer(msg.sender, payout);
}
}
2. Reentrancy Protection
Although we follow CEI, we also use state flags:
// The `claimed` flag is set BEFORE external call
position.claimed = true; // EFFECT
// ...
IERC20(config.stablecoin).transfer(...); // INTERACTION
3. Integer Overflow Protection
Solidity 0.8+ has built-in overflow checks, but we're explicit:
// Safe accumulation
market.yesPool += amount; // Reverts on overflow in 0.8+
4. Access Control
modifier onlyAdmin() {
require(msg.sender == config.admin, NotAdmin());
_;
}
modifier whenNotPaused() {
require(!config.paused, Paused());
_;
}
5. Input Validation
function createMarket(
string calldata question,
uint256 resolutionTime,
uint256 fee
) external whenNotPaused returns (uint256) {
require(bytes(question).length > 0, EmptyQuestion());
require(resolutionTime > block.timestamp, InvalidResolutionTime());
// ...
}
6. Balance Checks Before Transfer
function placeBet(...) external {
require(
IERC20(config.stablecoin).balanceOf(msg.sender) >= amount,
InsufficientBalance()
);
require(
IERC20(config.stablecoin).allowance(msg.sender, address(this)) >= amount,
InsufficientAllowance()
);
// ...
}
Gas Optimization Techniques
1. Custom Errors (Solidity 0.8.4+)
// Gas expensive
require(condition, "This is an error message");
// Gas efficient (saves ~50 gas per error)
error NotAdmin();
require(condition, NotAdmin());
2. Calldata vs Memory
// Use calldata for read-only dynamic parameters
function createMarket(
string calldata question, // calldata, not memory
uint256 resolutionTime,
uint256 fee
) external { ... }
3. Storage Packing
struct Config {
address admin; // 20 bytes
bool paused; // 1 byte ─┐
uint8 decimals; // 1 byte ─┼─ packed into same slot
uint16 maxFee; // 2 bytes ─┘
}
4. Unchecked Arithmetic (Where Safe)
// When we know overflow is impossible
unchecked {
for (uint256 i = 0; i < marketIds.length; ++i) {
// ++i is cheaper than i++
}
}
5. Short-Circuit Evaluation
// Cheaper check first
require(market.state == MarketState.Active &&
block.timestamp < market.resolutionTime,
MarketNotActive());
Testing with Foundry
Test Structure
test/
├── BaseTest.sol # Common setup and helpers
├── unit/
│ ├── MarketCreation.t.sol
│ ├── Betting.t.sol
│ ├── Resolution.t.sol
│ ├── Cancellation.t.sol
│ ├── Claiming.t.sol
│ ├── AccessControl.t.sol
│ └── ViewFunctions.t.sol
├── integration/
│ └── MarketLifecycle.t.sol
└── fuzz/
└── PayoutFuzz.t.sol
Base Test Setup
abstract contract BaseTest is Test {
PredictionMarket public market;
MockERC20 public stablecoin;
address public admin = makeAddr("admin");
address public alice = makeAddr("alice");
address public bob = makeAddr("bob");
uint256 constant DECIMALS = 6;
uint256 constant ONE_WEEK = 7 days;
function setUp() public virtual {
vm.startPrank(admin);
stablecoin = new MockERC20("USDC", "USDC", DECIMALS);
market = new PredictionMarket(
address(stablecoin),
DECIMALS,
admin,
feeRecipient,
500 // 5% max fee
);
vm.stopPrank();
// Fund test accounts
stablecoin.mint(alice, usdc(10_000));
stablecoin.mint(bob, usdc(10_000));
// Approve
vm.prank(alice);
stablecoin.approve(address(market), type(uint256).max);
vm.prank(bob);
stablecoin.approve(address(market), type(uint256).max);
}
function usdc(uint256 amount) internal pure returns (uint256) {
return amount * 10**DECIMALS;
}
}
Unit Test Example
contract ClaimingTest is BaseTest {
function test_ClaimWinnings_WinningSide() public {
// Setup
uint256 marketId = createDefaultMarket();
placeBet(alice, marketId, Outcome.Yes, usdc(100));
placeBet(bob, marketId, Outcome.No, usdc(50));
warpToResolution(marketId);
resolveMarket(marketId, Outcome.Yes);
uint256 balanceBefore = stablecoin.balanceOf(alice);
// Execute
vm.prank(alice);
market.claimWinnings(marketId);
// Assert: 100 + (100/100) * 50 = 150
assertEq(
stablecoin.balanceOf(alice),
balanceBefore + usdc(150)
);
}
}
Fuzz Testing
contract PayoutFuzzTest is BaseTest {
function testFuzz_PayoutDistribution(
uint256 yesAmount,
uint256 noAmount
) public {
// Bound inputs to reasonable ranges
yesAmount = bound(yesAmount, usdc(1), usdc(1_000_000));
noAmount = bound(noAmount, usdc(1), usdc(1_000_000));
// Setup
uint256 marketId = createDefaultMarket();
placeBet(alice, marketId, Outcome.Yes, yesAmount);
placeBet(bob, marketId, Outcome.No, noAmount);
warpToResolution(marketId);
resolveMarket(marketId, Outcome.Yes);
// Claim
vm.prank(alice);
market.claimWinnings(marketId);
vm.prank(bob);
market.claimWinnings(marketId);
// Invariant: Contract should have 0 balance
assertEq(stablecoin.balanceOf(address(market)), 0);
}
}
Running Tests
# Run all tests
forge test
# Run with verbosity
forge test -vvv
# Run specific test
forge test --match-test test_ClaimWinnings
# Run with gas reporting
forge test --gas-report
# Run coverage
forge coverage
Test Results
Running 95 tests...
✓ All tests passed
Coverage:
- Line coverage: 98.35%
- Function coverage: 100%
- Branch coverage: 94.12%
Multi-Chain Deployment
Supported Networks
| Network | Chain ID | Stablecoin |
|---|---|---|
| Ethereum Mainnet | 1 | USDC |
| Base | 8453 | USDC |
| Polygon | 137 | USDC |
| Arbitrum One | 42161 | USDC |
| Optimism | 10 | USDC |
| BSC | 56 | USDT/BUSD |
Deployment Script
// script/Deploy.s.sol
contract DeployScript is Script {
function run() external {
uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
address stablecoin = vm.envOr("STABLECOIN_ADDRESS", address(0));
uint8 decimals = uint8(vm.envOr("STABLECOIN_DECIMALS", uint256(6)));
address admin = vm.envOr("ADMIN_ADDRESS", msg.sender);
address feeRecipient = vm.envOr("FEE_RECIPIENT", msg.sender);
uint16 maxFee = uint16(vm.envOr("MAX_FEE_PERCENTAGE", uint256(500)));
vm.startBroadcast(deployerPrivateKey);
// Deploy mock token if needed (testnet)
if (stablecoin == address(0)) {
MockERC20 token = new MockERC20("Mock USDC", "mUSDC", decimals);
stablecoin = address(token);
}
PredictionMarket market = new PredictionMarket(
stablecoin,
decimals,
admin,
feeRecipient,
maxFee
);
vm.stopBroadcast();
console.log("PredictionMarket deployed at:", address(market));
}
}
Deploy Commands
# Deploy to Base Sepolia (testnet)
forge script script/Deploy.s.sol:DeployScript \
--rpc-url $BASE_SEPOLIA_RPC \
--broadcast \
--verify
# Deploy to Polygon Mainnet
forge script script/Deploy.s.sol:DeployScript \
--rpc-url $POLYGON_MAINNET_RPC \
--broadcast \
--verify \
--etherscan-api-key $POLYGONSCAN_API_KEY
Foundry Configuration
# foundry.toml
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
optimizer = true
optimizer_runs = 200
via_ir = false
[rpc_endpoints]
ethereum = "${ETHEREUM_MAINNET_RPC}"
base = "${BASE_MAINNET_RPC}"
polygon = "${POLYGON_MAINNET_RPC}"
arbitrum = "${ARBITRUM_MAINNET_RPC}"
optimism = "${OPTIMISM_MAINNET_RPC}"
bsc = "${BSC_MAINNET_RPC}"
[etherscan]
ethereum = { key = "${ETHERSCAN_API_KEY}" }
base = { key = "${BASESCAN_API_KEY}" }
polygon = { key = "${POLYGONSCAN_API_KEY}" }
arbitrum = { key = "${ARBISCAN_API_KEY}" }
optimism = { key = "${OPSCAN_API_KEY}" }
bsc = { key = "${BSCSCAN_API_KEY}" }
Conclusion
This prediction market smart contract demonstrates:
Clean architecture with separation of concerns
Gas-efficient Solidity patterns
Comprehensive security measures
Thorough testing with Foundry
Multi-chain deployment capability
What's Next?
For a production deployment, consider adding:
Oracle Integration - Chainlink, UMA, or Reality.eth
Time-weighted fees - Dynamic fees based on market age
Liquidity incentives - Rewards for early participants
Governance - DAO-controlled resolution disputes
Cross-chain - LayerZero or Axelar for unified liquidity
Resources
Disclaimer: This code is for educational purposes only. It has not been audited and should not be used in production without proper security review.
Found this useful? Star the repo and follow for more Web3 tutorials!
SOCIAL SHARE CARD GENERATOR