WATTO Betting Platform

Survival Content Betting Platform

Role: Solo Developer

Platform Concept

Decentralized Betting Ecosystem

• ▶Episode-based betting pools
• ▶Real-time odds calculation
• ▶Automated payout distribution
• ▶Transparent result verification

Smart Contract Architecture

Betting Pool Management

• ▶Time-windowed betting (open/close/finalize)
• ▶Pool accounting and payout calculation
• ▶Oracle-based result finalization
• ▶Abuse prevention (minimum bet, validation, replay/claim protections)

Oracle System

Result Verification

solidity
contract WATTOOracle {
    address[] public oracles;
    mapping(uint256 => mapping(address => address)) public votes;  // episode -> oracle -> winner
    mapping(uint256 => uint256) public voteCount;
    
    uint256 public constant REQUIRED_VOTES = 3;
    
    function submitResult(uint256 episodeId, address winner) 
        external 
        onlyOracle 
    {
        require(votes[episodeId][msg.sender] == address(0), "Already voted");
        
        votes[episodeId][msg.sender] = winner;
        voteCount[episodeId]++;
        
        // Check if consensus reached
        if (hasConsensus(episodeId, winner)) {
            wattoPool.finalizeEpisode(episodeId, winner);
        }
    }
    
    function hasConsensus(uint256 episodeId, address winner) 
        internal 
        view 
        returns (bool) 
    {
        uint256 matchingVotes = 0;
        
        for (uint256 i = 0; i < oracles.length; i++) {
            if (votes[episodeId][oracles[i]] == winner) {
                matchingVotes++;
            }
        }
        
        return matchingVotes >= REQUIRED_VOTES;
    }
}

Backend Development

Real-Time Odds Calculation

javascript
// Odds Calculation Service
class OddsCalculator {
    calculateOdds(episodeId) {
        const episode = await getEpisode(episodeId);
        const contestants = episode.contestants;
        const odds = {};
        
        for (const contestant of contestants) {
            const totalPool = episode.totalPoolAmount;
            const contestantPool = episode.totalBets[contestant];
            
            if (contestantPool === 0) {
                odds[contestant] = 100.0;  // Long shot
            } else {
                // Calculate implied probability and convert to decimal odds
                const impliedProb = contestantPool / totalPool;
                odds[contestant] = (1 / impliedProb).toFixed(2);
            }
        }
        
        return odds;
    }
    
    async broadcastOddsUpdate(episodeId) {
        const newOdds = this.calculateOdds(episodeId);
        
        // WebSocket broadcast to all connected clients
        io.to(`episode-${episodeId}`).emit('odds-update', {
            episodeId,
            odds: newOdds,
            timestamp: Date.now()
        });
    }
}

Episode Management API

• ▶POST /api/episodes: Create new betting episode
• ▶GET /api/episodes/active: List open betting episodes
• ▶POST /api/bets: Place bet (calls smart contract)
• ▶GET /api/bets/user/:address: Get user bet history
• ▶GET /api/odds/:episodeId: Get current odds

Frontend Implementation

React Betting Interface

• ▶Episode Carousel: Browse upcoming and active episodes
• ▶Contestant Cards: View contestant stats and place bets
• ▶Live Odds Display: Real-time odds updates via WebSocket
• ▶Bet Slip: Shopping cart-style bet confirmation
• ▶Wallet Integration: MetaMask connection for transactions

User Dashboard

• ▶Portfolio overview (active bets, potential winnings)
• ▶Betting history and performance statistics
• ▶Claimable winnings with one-click claim
• ▶Transaction history

Team Leadership

Project Management

• ▶Sprint planning and task delegation
• ▶Code review and quality assurance
• ▶Technical architecture decisions
• ▶Stakeholder communication

Technical Stack Decisions

• ▶Blockchain: Ethereum (reliability for financial operations)
• ▶Frontend: React + Web3.js (widely adopted, good libraries)
• ▶Backend: Node.js + Express (team expertise)
• ▶Database: MongoDB (flexible schema for betting data)
• ▶Real-time: Socket.IO (odds updates, notifications)

Security Measures

Smart Contract Security

• ▶Reentrancy guards on withdrawal functions
• ▶Time-lock mechanisms for result finalization
• ▶Multi-signature oracle system to prevent manipulation
• ▶Emergency pause functionality

Backend Security

• ▶Rate limiting on bet placement API
• ▶Input validation and sanitization
• ▶HTTPS encryption for all communications
• ▶JWT-based authentication

Technical Achievements