WATTO Betting Platform

Survival Content Betting Platform

Role: Solo Developer

Designed and built WATTO as a decentralized betting platform concept for survival-themed content, covering both smart contracts and supporting backend/UX flows.

---

Platform Concept

Decentralized Betting Ecosystem

Created a trustless betting system where users can wager on outcomes of survival content episodes and challenges.

Core Features:

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

---

Smart Contract Architecture

Betting Pool Management

Designed smart contracts to handle complex betting mechanics with fairness guarantees. Key contract concerns were:

• 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

Implemented a multi-signature oracle system for trusted result reporting.

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

Implemented live odds engine that updates based on betting activity:

// 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

Built RESTful API for content management:

• 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

Developed interactive UI for seamless betting experience:

Key Components:

• 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

Personal betting analytics:

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

---

Team Leadership

Project Management

As Team Lead, coordinated development across multiple workstreams:

• 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