Prediction Market Smart Contract (Polymarket-Style)

You launch a DeFi protocol where users bet on event outcomes — from sports matches to ETH price. The first version of your contract in JavaScript with Web3 fails under load: reentrancy in redeem, oracle manipulation leads to loss of funds, and gas cost on the AMM exceeds the 15 million block limit. Sound familiar? We rewrite such contracts from scratch.

How Prediction Markets Work on Blockchain

Each market is a pair of conditional tokens: YES and NO. A user deposits 1 USDC and receives 1 YES + 1 NO token via the Conditional Tokens Framework (CTF) from Gnosis. Then they sell the unwanted outcome on an AMM or CLOB. After resolution, the winning token is redeemed for 1 USDC, the losing token for 0.

Conditional Tokens Framework (CTF) — an ERC-1155 standard for conditional tokens. Each outcome is represented as a position with a unique positionId. At resolution, CTF allows redeeming winning positions.

// Gnosis CTF interface
interface IConditionalTokens {
    function prepareCondition(
        address oracle,
        bytes32 questionId,
        uint outcomeSlotCount
    ) external;
    
    function reportPayouts(
        bytes32 questionId,
        uint[] calldata payouts
    ) external;
    
    function redeemPositions(
        IERC20 collateralToken,
        bytes32 parentCollectionId,
        bytes32 conditionId,
        uint[] calldata indexSets
    ) external;
}

AMM vs CLOB: What to Choose for Your Market

Polymarket uses CLOB for speed. For a fully decentralized market, AMM is better. LMSR is mathematically elegant, but Constant Product AMM is about 3x cheaper in gas — a good choice for markets with balanced liquidity.

Why AMM is Better for a Fully Decentralized Market

LMSR (Logarithmic Market Scoring Rule) — the classic AMM for prediction markets. The price depends on the quantity of YES and NO tokens sold:

price_yes = e^(q_yes/b) / (e^(q_yes/b) + e^(q_no/b))

where b is the liquidity parameter. LMSR guarantees that the market maker always accepts bets, and the maximum loss is bounded by b * ln(2). Constant Product AMM (like Uniswap v2) is simpler in gas, but prices are less accurate near 0% or 100%. We use a modified constant product with a price range limit [0.02, 0.98] — this protects against infinite losses at extreme outcomes.

Oracle and Resolution: Where the Main Complexity Hides

A prediction market without a reliable oracle is a market with manual arbitrage, always under threat. Three approaches:

• Chainlink Data Feeds — for financial markets (ETH price above $5000?). Deterministic, decentralized, but covers only finance.
• UMA Optimistic Oracle — for subjective questions (election outcome). Proposal + dispute period + dispute through UMA token holders. 2–48 hours delay, but works for any question.
• Custom multisig oracle — a set of trusted parties (5/9 multisig) votes on the outcome. Centralized but transparent and fast. For private markets.

contract PredictionMarket {
    struct Market {
        bytes32 conditionId;
        address oracle;
        uint256 endTime;
        uint256 resolutionTime;
        MarketStatus status;
        uint128 yesReserve;
        uint128 noReserve;
        uint256 totalVolume;
    }
    
    enum MarketStatus { Open, Closed, Resolved, Disputed }
    
    mapping(bytes32 => Market) public markets;
    
    // AMM pricing
    function getPrice(bytes32 marketId, bool isYes) public view returns (uint256) {
        Market storage m = markets[marketId];
        uint256 yesR = m.yesReserve;
        uint256 noR = m.noReserve;
        // constant product: price_yes = noR / (yesR + noR) in fixed point
        return (noR * 1e18) / (yesR + noR);
    }
}

How to Protect Against Manipulation and Attacks

• Oracle manipulation. If a market resolves based on an on-chain price at a specific moment, a flash loan attack is possible. Protection: TWAP over 24–48 hours instead of spot price, multiple independent sources.
• Front-running of resolution. Someone learns the outcome before official resolution and buys tokens at old prices. Solution: stop trading X hours before resolution.
• Griefing through spam disputes. In optimistic oracle systems, an attacker disputes every resolution. Protection: bond requirement for disputes (collateral lost if the dispute fails).
• Reentrancy during redeem. CTF.redeemPositions transfers tokens before updating state. Use Check-Effects-Interactions + ReentrancyGuard.
• Wrong conditionId. CTF uses keccak256(oracle, questionId, outcomeSlotCount). Verify conditionId twice before deployment.

Governance and Market Creation

Who can create markets? Options:

• Permissioned. Only whitelisted operators. Centralized but protects against spam markets.
• Permissionless with a bond. Anyone who pays a bond. Bond is returned on correct resolution.
• DAO governance. Voting for each market. Slow but decentralized.

For MVP — permissioned with a roadmap to DAO.

Development Stack

• Foundry — primary tool. Fuzz tests for AMM math.
• Gnosis CTF — use the ready-made implementation.
• Chainlink — oracle for financial markets.
• OpenZeppelin — AccessControl, ReentrancyGuard, Pausable.
• Slither + Echidna — static analysis and property-based testing.

Total timeline — from 1–2 weeks (contracts only) to 4–6 weeks (full platform).

What's Included

• Documentation: technical specification, white paper, API specs.
• Source code of smart contracts with open license.
• Deployment to the chosen network (Ethereum, Polygon, Arbitrum, BNB Chain).
• Security audit with report.
• Integration with frontend (optional) and The Graph subgraph.
• Technical support for 3 months after deployment.

We will evaluate your project within 1–2 days. Contact us to discuss details. Get a consultation on your protocol.

Smart Contract Development

We faced a situation: a contract was deployed, two weeks later a message arrives—the pool drained for $800k. Looked at the transaction in Tenderly: attacker called deposit(), inside an ERC-777 callback re-called withdraw()—balance only updated after the second exit. Classic reentrancy, but not via ETH transfer—through an ERC-777 hook. ReentrancyGuard was only on withdraw().

Such cases are not rare. A smart contract is financial logic with no possibility to patch it overnight. Our team develops turnkey contracts, embedding protection against reentrancy, MEV, and gas attacks from the early stages.

How We Develop Smart Contracts Turnkey

We start with business logic audit and stack selection. Solidity 0.8.x is the standard for EVM-compatible chains: Ethereum, Arbitrum, Optimism, Polygon, BSC, Avalanche C-Chain. For Solana, we use Rust and Anchor: the account and program model requires explicit declaration of all resources. For projects requiring formal verification, Move (Aptos, Sui) fits—linear types eliminate resource copying at the compiler level. Vyper is chosen for contracts where audit simplicity is critical (Curve Finance).

Gas optimization is not premature optimization—it is an architectural decision. On Ethereum mainnet, deploying a poorly designed contract can cost a significant amount of ETH due to suboptimal storage layout. Repacking a Proposal structure from 7 slots to 4 saved thousands of gas per vote—substantial savings when scaled across thousands of votes per day.

Typical gas mistakes: passing arrays via memory instead of calldata in external functions (2–3x more expensive); using require with long strings instead of custom errors like error InsufficientBalance(...). Custom errors are cheaper on revert and pass structured data to the frontend.

Why Smart Contract Audit Is Critical for Security

Audit is not a one-time check—it is a built-in development stage. We use three levels:

1. Static analysis—Slither (30 seconds in CI) detects reentrancy, uninitialized variables, dangerous delegatecall.
2. Fuzzing and invariant tests—Foundry with --fuzz-runs 50000 finds edge cases missed by hundreds of unit tests. Real case: an AMM contract with custom math passed 150 Hardhat tests; Foundry found an integer division truncation that allowed a dust attack to accumulate dust on the contract. Echidna checks invariants ("sum of all balances ≤ totalSupply").
3. Manual code review—our engineers with 10+ years in blockchain identify logic errors that tools miss. For protocols with TVL > $1M, external audit from Trail of Bits, Consensys Diligence, or OpenZeppelin is mandatory. Timeline: 2–4 weeks.

Any upgradeable protocol must have a timelock. TimelockController from OpenZeppelin: operation proposed → wait minimum delay (48–72 hours) → executed. Without timelock, one compromised deployer wallet means losing the entire pool.

What Upgrade Patterns Do We Choose?

Storage collision is the main danger of proxies. Implementation v2 must not add variables before existing ones. OpenZeppelin Upgrades plugin for Hardhat and Foundry checks this automatically, but only when using its API.

How to Protect a Contract from MEV and Front-Running

On Ethereum mainnet, transactions in the mempool are visible to all. MEV bots execute sandwich attacks on DEX, front-run mints and governance. Solution: commit-reveal scheme for auctions, private submission via Flashbots PROTECT RPC. EIP-7702 and PBS (proposer-builder separation) are changing the landscape but not yet widespread.

What Is the Development Process?

1. Analysis—functional specification, call diagram, edge case analysis. Without this, coding starts in vain.
2. Development—Solidity/Rust with tests in parallel. Test → code → refactoring. Use Foundry for fuzz and invariant tests.
3. Internal audit—Slither + Echidna + manual code review. Foundry invariant tests for protocol invariants.
4. External audit—for projects with real money. Timeline: 2–4 weeks.
5. Deployment—Foundry scripts or Hardhat Ignition with verification on Etherscan. Gnosis Safe for ownership transfer immediately after deployment.
6. Monitoring—Tenderly alerts, OpenZeppelin Defender, Forta Network.

What Is Included

• Architecture documentation and contract specification (NatSpec).
• Source code with repository and CI (Slither, Foundry, coverage).
• Deployed contract with verification on blockchain explorer.
• Audit results (internal and external upon request).
• Access to monitoring and management (Gnosis Safe).
• Code warranty: critical bug fixes within one month after deployment.
• Consultation on web integration (wagmi, RainbowKit).

Estimated Timelines

• ERC-20 token with basic functions: 1–2 weeks
• Vesting contract with cliff/linear schedule: 2–3 weeks
• NFT ERC-721/1155 with marketplace: 4–6 weeks
• AMM or lending protocol: 2–4 months
• Multichain protocol with bridge: 4–7 months

Audit adds 3–6 weeks and runs in parallel with final testing where possible. Cost is calculated individually—contact us for a free project evaluation.

Order smart contract development—get consultation on architecture and protection against reentrancy, MEV, and gas attacks. Want to discuss details? Write to us—we will select the optimal stack for your task.