How to Build Stablecoin Prediction Market: Augur V2 Implementation

# Install dependencies
npm install -g @augurproject/tools
npm install -g ganache-cli

# Clone Augur V2 contracts
git clone https://github.com/AugurProject/augur.git
cd augur/packages/augur-core

# Install and compile contracts
npm install
npm run build

# Start local blockchain with specific configuration
ganache-cli \
  --host 0.0.0.0 \
  --port 8545 \
  --networkId 5777 \
  --accounts 10 \
  --defaultBalanceEther 1000 \
  --gasLimit 8000000 \
  --gasPrice 1 \
  --deterministic

// scripts/deploy.js
const { ethers } = require("hardhat");
const fs = require('fs');

async function main() {
    console.log("Deploying Augur V2 with stablecoin support...");
    
    const [deployer] = await ethers.getSigners();
    console.log("Deploying with account:", deployer.address);
    
    // Deploy cash token (USDC proxy for testing)
    const Cash = await ethers.getContractFactory("Cash");
    const cash = await Cash.deploy();
    await cash.deployed();
    console.log("Cash token deployed to:", cash.address);
    
    // Deploy Universe
    const Universe = await ethers.getContractFactory("Universe");
    const universe = await Universe.deploy();
    await universe.deployed();
    
    // Initialize Universe with cash token
    await universe.initialize(cash.address);
    console.log("Universe deployed to:", universe.address);
    
    // Deploy ShareToken
    const ShareToken = await ethers.getContractFactory("ShareToken");
    const shareToken = await ShareToken.deploy();
    await shareToken.deployed();
    console.log("ShareToken deployed to:", shareToken.address);
    
    // Deploy AugurTrading (AMM)
    const AugurTrading = await ethers.getContractFactory("AugurTrading");
    const trading = await AugurTrading.deploy();
    await trading.deployed();
    
    await trading.initialize(universe.address, shareToken.address);
    console.log("AugurTrading deployed to:", trading.address);
    
    // Save deployment addresses
    const deploymentInfo = {
        cash: cash.address,
        universe: universe.address,
        shareToken: shareToken.address,
        trading: trading.address,
        deployer: deployer.address
    };
    
    fs.writeFileSync(
        'deployment-info.json', 
        JSON.stringify(deploymentInfo, null, 2)
    );
    
    console.log("Deployment complete!");
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

// contracts/StablecoinPredictionMarket.sol
pragma solidity ^0.8.0;

import "@augurproject/core/contracts/Universe.sol";
import "@augurproject/core/contracts/Market.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract StablecoinPredictionMarket is ReentrancyGuard, Ownable {
    Universe public universe;
    IERC20 public stablecoin;
    
    struct MarketDetails {
        string question;
        string[] outcomes;
        uint256 endTime;
        uint256 resolutionTime;
        uint256 feeRate;
        address oracle;
        bool isResolved;
        uint256 winningOutcome;
    }
    
    mapping(address => MarketDetails) public markets;
    address[] public marketsList;
    
    event MarketCreated(
        address indexed market,
        string question,
        uint256 endTime,
        uint256 numOutcomes
    );
    
    event MarketResolved(
        address indexed market,
        uint256 winningOutcome
    );
    
    constructor(address _universe, address _stablecoin) {
        universe = Universe(_universe);
        stablecoin = IERC20(_stablecoin);
    }
    
    function createMarket(
        string memory _question,
        string[] memory _outcomes,
        uint256 _endTime,
        uint256 _resolutionTime,
        uint256 _feeRate,
        address _oracle
    ) external nonReentrant returns (address) {
        require(_endTime > block.timestamp, "End time must be in future");
        require(_resolutionTime > _endTime, "Resolution must be after end time");
        require(_outcomes.length >= 2, "Must have at least 2 outcomes");
        require(_feeRate <= 300, "Fee rate cannot exceed 3%"); // 300 basis points = 3%
        
        // Create market through Augur Universe
        Market market = universe.createBinaryMarket(
            _endTime,
            _feeRate,
            _oracle,
            _question
        );
        
        // Store market details
        markets[address(market)] = MarketDetails({
            question: _question,
            outcomes: _outcomes,
            endTime: _endTime,
            resolutionTime: _resolutionTime,
            feeRate: _feeRate,
            oracle: _oracle,
            isResolved: false,
            winningOutcome: 0
        });
        
        marketsList.push(address(market));
        
        emit MarketCreated(
            address(market),
            _question,
            _endTime,
            _outcomes.length
        );
        
        return address(market);
    }
    
    function resolveMarket(
        address _market,
        uint256 _winningOutcome
    ) external {
        MarketDetails storage marketDetails = markets[_market];
        require(msg.sender == marketDetails.oracle, "Only oracle can resolve");
        require(block.timestamp >= marketDetails.resolutionTime, "Too early to resolve");
        require(!marketDetails.isResolved, "Market already resolved");
        require(_winningOutcome < marketDetails.outcomes.length, "Invalid outcome");
        
        Market market = Market(_market);
        
        // Resolve market on Augur
        uint256[] memory payouts = new uint256[](marketDetails.outcomes.length);
        payouts[_winningOutcome] = 1000; // 100% payout to winning outcome
        
        market.doInitialReport(payouts);
        
        marketDetails.isResolved = true;
        marketDetails.winningOutcome = _winningOutcome;
        
        emit MarketResolved(_market, _winningOutcome);
    }
}

// contracts/StablecoinAMM.sol
pragma solidity ^0.8.0;

import "@augurproject/core/contracts/trading/ShareToken.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract StablecoinAMM is ReentrancyGuard {
    ShareToken public shareToken;
    IERC20 public stablecoin;
    
    // AMM parameters
    uint256 public constant FEE_RATE = 30; // 0.3%
    uint256 public constant FEE_DIVISOR = 10000;
    
    struct LiquidityPool {
        uint256[] reserves; // Reserve for each outcome
        uint256 totalLiquidity;
        mapping(address => uint256) liquidityShares;
        uint256 k; // Constant product (x * y * z...)
    }
    
    mapping(address => LiquidityPool) public pools;
    
    event LiquidityAdded(
        address indexed market,
        address indexed provider,
        uint256[] amounts,
        uint256 liquidityMinted
    );
    
    event Trade(
        address indexed market,
        address indexed trader,
        uint256 outcomeIn,
        uint256 outcomeOut,
        uint256 amountIn,
        uint256 amountOut
    );
    
    constructor(address _shareToken, address _stablecoin) {
        shareToken = ShareToken(_shareToken);
        stablecoin = IERC20(_stablecoin);
    }
    
    function addLiquidity(
        address _market,
        uint256[] memory _amounts
    ) external nonReentrant {
        require(_amounts.length >= 2, "Need amounts for all outcomes");
        
        LiquidityPool storage pool = pools[_market];
        
        // Transfer tokens from user
        for (uint256 i = 0; i < _amounts.length; i++) {
            require(_amounts[i] > 0, "Amount must be positive");
            shareToken.safeTransferFrom(
                msg.sender,
                address(this),
                getTokenId(_market, i),
                _amounts[i],
                ""
            );
        }
        
        uint256 liquidityMinted;
        
        if (pool.totalLiquidity == 0) {
            // Initial liquidity provision
            liquidityMinted = calculateGeometricMean(_amounts);
            pool.reserves = _amounts;
        } else {
            // Proportional liquidity addition
            liquidityMinted = calculateProportionalLiquidity(pool, _amounts);
            for (uint256 i = 0; i < _amounts.length; i++) {
                pool.reserves[i] += _amounts[i];
            }
        }
        
        pool.totalLiquidity += liquidityMinted;
        pool.liquidityShares[msg.sender] += liquidityMinted;
        pool.k = calculateConstantProduct(pool.reserves);
        
        emit LiquidityAdded(_market, msg.sender, _amounts, liquidityMinted);
    }
    
    function swapOutcomes(
        address _market,
        uint256 _outcomeIn,
        uint256 _outcomeOut,
        uint256 _amountIn,
        uint256 _minAmountOut
    ) external nonReentrant {
        LiquidityPool storage pool = pools[_market];
        require(pool.totalLiquidity > 0, "No liquidity");
        require(_outcomeIn != _outcomeOut, "Cannot swap same outcome");
        
        // Calculate output amount using constant product formula
        uint256 amountOut = calculateSwapOutput(
            pool.reserves[_outcomeIn],
            pool.reserves[_outcomeOut],
            _amountIn
        );
        
        require(amountOut >= _minAmountOut, "Insufficient output amount");
        
        // Apply fees
        uint256 fee = (amountOut * FEE_RATE) / FEE_DIVISOR;
        amountOut -= fee;
        
        // Execute swap
        shareToken.safeTransferFrom(
            msg.sender,
            address(this),
            getTokenId(_market, _outcomeIn),
            _amountIn,
            ""
        );
        
        shareToken.safeTransfer(
            msg.sender,
            getTokenId(_market, _outcomeOut),
            amountOut
        );
        
        // Update reserves
        pool.reserves[_outcomeIn] += _amountIn;
        pool.reserves[_outcomeOut] -= amountOut;
        
        emit Trade(_market, msg.sender, _outcomeIn, _outcomeOut, _amountIn, amountOut);
    }
    
    function calculateSwapOutput(
        uint256 _reserveIn,
        uint256 _reserveOut,
        uint256 _amountIn
    ) public pure returns (uint256) {
        // Constant product formula: x * y = k
        // New reserve in: x + dx
        // New reserve out: y - dy
        // (x + dx) * (y - dy) = k = x * y
        // dy = y - (x * y) / (x + dx)
        
        uint256 numerator = _reserveOut * _amountIn;
        uint256 denominator = _reserveIn + _amountIn;
        
        return numerator / denominator;
    }
    
    function calculateGeometricMean(uint256[] memory _amounts) 
        internal 
        pure 
        returns (uint256) 
    {
        uint256 product = _amounts[0];
        for (uint256 i = 1; i < _amounts.length; i++) {
            product *= _amounts[i];
        }
        
        // Simplified geometric mean for small arrays
        return sqrt(product);
    }
    
    function getTokenId(address _market, uint256 _outcome) 
        internal 
        pure 
        returns (uint256) 
    {
        return uint256(keccak256(abi.encodePacked(_market, _outcome)));
    }
    
    // Simple square root implementation
    function sqrt(uint256 _x) internal pure returns (uint256) {
        if (_x == 0) return 0;
        uint256 z = (_x + 1) / 2;
        uint256 y = _x;
        while (z < y) {
            y = z;
            z = (_x / z + z) / 2;
        }
        return y;
    }
}

// oracle/PredictionOracle.js
const axios = require('axios');
const { ethers } = require('ethers');

class PredictionOracle {
    constructor(privateKey, contractAddress, provider) {
        this.wallet = new ethers.Wallet(privateKey, provider);
        this.contract = new ethers.Contract(
            contractAddress,
            require('./abi/StablecoinPredictionMarket.json'),
            this.wallet
        );
        
        this.dataSources = {
            sports: 'https://api.sportsdata.io',
            elections: 'https://api.ap.org',
            crypto: 'https://api.coingecko.com',
            weather: 'https://api.openweathermap.org'
        };
        
        this.pendingResolutions = new Map();
    }
    
    async monitorMarkets() {
        console.log('Starting market monitoring...');
        
        setInterval(async () => {
            try {
                await this.checkPendingResolutions();
            } catch (error) {
                console.error('Error in monitoring cycle:', error);
            }
        }, 60000); // Check every minute
    }
    
    async checkPendingResolutions() {
        const marketsList = await this.contract.marketsList();
        
        for (const marketAddress of marketsList) {
            const marketDetails = await this.contract.markets(marketAddress);
            
            if (!marketDetails.isResolved && 
                Date.now() / 1000 >= marketDetails.resolutionTime) {
                
                console.log(`Market ready for resolution: ${marketAddress}`);
                await this.resolveMarket(marketAddress, marketDetails);
            }
        }
    }
    
    async resolveMarket(marketAddress, marketDetails) {
        try {
            const question = marketDetails.question;
            const outcomes = marketDetails.outcomes;
            
            // Determine market category from question
            const category = this.categorizeMarket(question);
            const winningOutcome = await this.fetchResolution(category, question, outcomes);
            
            if (winningOutcome !== null) {
                // Double-check resolution with multiple sources
                const confirmed = await this.confirmResolution(category, question, winningOutcome);
                
                if (confirmed) {
                    const tx = await this.contract.resolveMarket(
                        marketAddress,
                        winningOutcome,
                        { gasLimit: 500000 }
                    );
                    
                    await tx.wait();
                    console.log(`Market resolved: ${marketAddress}, outcome: ${winningOutcome}`);
                } else {
                    console.log(`Resolution not confirmed for market: ${marketAddress}`);
                    // Add to pending resolutions for manual review
                    this.pendingResolutions.set(marketAddress, {
                        question,
                        outcomes,
                        suspectedOutcome: winningOutcome,
                        timestamp: Date.now()
                    });
                }
            }
        } catch (error) {
            console.error(`Failed to resolve market ${marketAddress}:`, error);
        }
    }
    
    categorizeMarket(question) {
        const lowerQuestion = question.toLowerCase();
        
        if (lowerQuestion.includes('election') || lowerQuestion.includes('vote')) {
            return 'elections';
        } else if (lowerQuestion.includes('price') || lowerQuestion.includes('btc') || lowerQuestion.includes('eth')) {
            return 'crypto';
        } else if (lowerQuestion.includes('weather') || lowerQuestion.includes('temperature')) {
            return 'weather';
        } else if (lowerQuestion.includes('game') || lowerQuestion.includes('match') || lowerQuestion.includes('team')) {
            return 'sports';
        }
        
        return 'general';
    }
    
    async fetchResolution(category, question, outcomes) {
        switch (category) {
            case 'crypto':
                return await this.resolveCryptoMarket(question, outcomes);
            case 'sports':
                return await this.resolveSportsMarket(question, outcomes);
            case 'weather':
                return await this.resolveWeatherMarket(question, outcomes);
            case 'elections':
                return await this.resolveElectionMarket(question, outcomes);
            default:
                return await this.resolveGeneralMarket(question, outcomes);
        }
    }
    
    async resolveCryptoMarket(question, outcomes) {
        try {
            // Extract cryptocurrency and target price from question
            const cryptoMatch = question.match(/(BTC|ETH|bitcoin|ethereum)/i);
            const priceMatch = question.match(/\$?(\d+(?:,\d+)*(?:\.\d+)?)/);
            
            if (!cryptoMatch || !priceMatch) {
                throw new Error('Cannot parse crypto market question');
            }
            
            const crypto = cryptoMatch[1].toLowerCase() === 'bitcoin' ? 'bitcoin' : 
                          cryptoMatch[1].toLowerCase() === 'btc' ? 'bitcoin' :
                          cryptoMatch[1].toLowerCase() === 'ethereum' ? 'ethereum' : 'ethereum';
            
            const targetPrice = parseFloat(priceMatch[1].replace(/,/g, ''));
            
            const response = await axios.get(
                `${this.dataSources.crypto}/v1/simple/price?ids=${crypto}&vs_currencies=usd`
            );
            
            const currentPrice = response.data[crypto].usd;
            
            // Determine outcome based on price comparison
            if (question.toLowerCase().includes('above') || question.toLowerCase().includes('exceed')) {
                return currentPrice > targetPrice ? 0 : 1; // Yes : No
            } else if (question.toLowerCase().includes('below') || question.toLowerCase().includes('under')) {
                return currentPrice < targetPrice ? 0 : 1; // Yes : No
            }
            
            throw new Error('Cannot determine price comparison direction');
            
        } catch (error) {
            console.error('Error resolving crypto market:', error);
            return null;
        }
    }
    
    async resolveSportsMarket(question, outcomes) {
        // Implementation for sports data resolution
        // This would integrate with sports APIs to get game results
        console.log('Sports market resolution not implemented yet');
        return null;
    }
    
    async confirmResolution(category, question, outcome) {
        // Implement cross-verification with multiple data sources
        // This adds an extra layer of security for high-value markets
        
        try {
            // Wait 5 minutes and check again
            await new Promise(resolve => setTimeout(resolve, 300000));
            
            const secondResolution = await this.fetchResolution(category, question, []);
            return secondResolution === outcome;
            
        } catch (error) {
            console.error('Error confirming resolution:', error);
            return false;
        }
    }
}

module.exports = PredictionOracle;

// components/PredictionMarket.jsx
import React, { useState, useEffect } from 'react';
import { ethers } from 'ethers';
import { Card, Button, Input, Progress, Modal } from 'antd';

const PredictionMarket = ({ marketAddress, web3Provider }) => {
    const [marketData, setMarketData] = useState(null);
    const [userPosition, setUserPosition] = useState(null);
    const [tradeAmount, setTradeAmount] = useState('');
    const [selectedOutcome, setSelectedOutcome] = useState(0);
    const [loading, setLoading] = useState(false);
    const [prices, setPrices] = useState([]);
    
    useEffect(() => {
        loadMarketData();
        const interval = setInterval(loadMarketData, 30000); // Update every 30 seconds
        return () => clearInterval(interval);
    }, [marketAddress]);
    
    const loadMarketData = async () => {
        try {
            const contract = new ethers.Contract(
                marketAddress,
                require('../abi/StablecoinPredictionMarket.json'),
                web3Provider
            );
            
            const details = await contract.markets(marketAddress);
            const reserves = await contract.getReserves(marketAddress);
            
            // Calculate current prices from AMM reserves
            const totalReserves = reserves.reduce((sum, reserve) => sum + parseFloat(reserve), 0);
            const calculatedPrices = reserves.map(reserve => 
                (parseFloat(reserve) / totalReserves * 100).toFixed(2)
            );
            
            setMarketData({
                question: details.question,
                outcomes: details.outcomes,
                endTime: details.endTime,
                isResolved: details.isResolved,
                winningOutcome: details.winningOutcome
            });
            
            setPrices(calculatedPrices);
            
            // Load user position
            const signer = web3Provider.getSigner();
            const userAddress = await signer.getAddress();
            const position = await getUserPosition(userAddress);
            setUserPosition(position);
            
        } catch (error) {
            console.error('Error loading market data:', error);
        }
    };
    
    const executeTrader = async () => {
        if (!tradeAmount || !marketData) return;
        
        setLoading(true);
        try {
            const signer = web3Provider.getSigner();
            const contract = new ethers.Contract(
                marketAddress,
                require('../abi/StablecoinPredictionMarket.json'),
                signer
            );
            
            const amount = ethers.utils.parseEther(tradeAmount);
            
            // Calculate expected output
            const expectedOutput = await contract.calculateTradeOutput(
                selectedOutcome,
                amount
            );
            
            // Execute trade with slippage protection
            const minOutput = expectedOutput.mul(95).div(100); // 5% slippage tolerance
            
            const tx = await contract.buyShares(
                selectedOutcome,
                amount,
                minOutput,
                { gasLimit: 300000 }
            );
            
            await tx.wait();
            
            // Refresh data
            await loadMarketData();
            setTradeAmount('');
            
            Modal.success({
                title: 'Trade Successful',
                content: `You bought ${ethers.utils.formatEther(expectedOutput)} shares of "${marketData.outcomes[selectedOutcome]}"`
            });
            
        } catch (error) {
            console.error('Trade failed:', error);
            Modal.error({
                title: 'Trade Failed',
                content: error.message || 'Transaction failed. Please try again.'
            });
        } finally {
            setLoading(false);
        }
    };
    
    if (!marketData) {
        return <div>Loading market data...</div>;
    }
    
    return (
        <Card 
            title={marketData.question}
            className="prediction-market-card"
            extra={
                <span className={marketData.isResolved ? 'resolved' : 'active'}>
                    {marketData.isResolved ? 'Resolved' : 'Active'}
                </span>
            }
        >
            <div className="market-info">
                <p><strong>End Time:</strong> {new Date(marketData.endTime * 1000).toLocaleDateString()}</p>
                
                {marketData.isResolved && (
                    <div className="resolution-info">
                        <p><strong>Winning Outcome:</strong> {marketData.outcomes[marketData.winningOutcome]}</p>
                    </div>
                )}
                
                {!marketData.isResolved && (
                    <div className="outcomes-section">
                        <h4>Current Prices:</h4>
                        {marketData.outcomes.map((outcome, index) => (
                            <div key={index} className="outcome-row">
                                <div className="outcome-info">
                                    <span className="outcome-name">{outcome}</span>
                                    <span className="outcome-price">{prices[index]}¢</span>
                                </div>
                                <Progress 
                                    percent={parseFloat(prices[index])} 
                                    showInfo={false}
                                    strokeColor={index === 0 ? '#52c41a' : '#f5222d'}
                                />
                                <Button 
                                    type={selectedOutcome === index ? 'primary' : 'default'}
                                    onClick={() => setSelectedOutcome(index)}
                                    className="select-outcome-btn"
                                >
                                    Select
                                </Button>
                            </div>
                        ))}
                        
                        <div className="trading-section">
                            <h4>Place Trade:</h4>
                            <div className="trade-inputs">
                                <Input 
                                    placeholder="Amount (USDC)"
                                    value={tradeAmount}
                                    onChange={(e) => setTradeAmount(e.target.value)}
                                    type="number"
                                    step="0.1"
                                />
                                <Button 
                                    type="primary"
                                    onClick={executeTrader}
                                    loading={loading}
                                    disabled={!tradeAmount || marketData.isResolved}
                                >
                                    Buy {marketData.outcomes[selectedOutcome]}
                                </Button>
                            </div>
                        </div>
                    </div>
                )}
                
                {userPosition && (
                    <div className="user-position">
                        <h4>Your Position:</h4>
                        {userPosition.map((position, index) => (
                            <div key={index} className="position-row">
                                <span>{marketData.outcomes[index]}: {position} shares</span>
                            </div>
                        ))}
                    </div>
                )}
            </div>
        </Card>
    );
};

export default PredictionMarket;

// bots/MarketMaker.js
class PredictionMarketMaker {
    constructor(privateKey, contractAddress, provider) {
        this.wallet = new ethers.Wallet(privateKey, provider);
        this.contract = new ethers.Contract(
            contractAddress,
            require('../abi/StablecoinAMM.json'),
            this.wallet
        );
        
        this.targetSpread = 0.02; // 2% spread
        this.maxPositionSize = ethers.utils.parseEther('1000'); // 1000 USDC max
        this.rebalanceThreshold = 0.1; // Rebalance when reserves drift 10%
    }
    
    async startMarketMaking(marketAddress) {
        console.log(`Starting market making for ${marketAddress}`);
        
        // Initial liquidity provision
        await this.provideLiquidity(marketAddress);
        
        // Start monitoring and rebalancing
        setInterval(async () => {
            await this.monitorAndRebalance(marketAddress);
        }, 30000); // Every 30 seconds
    }
    
    async provideLiquidity(marketAddress) {
        try {
            const numOutcomes = await this.getNumOutcomes(marketAddress);
            
            // Provide equal liquidity to all outcomes initially
            const amountPerOutcome = this.maxPositionSize.div(numOutcomes);
            const amounts = new Array(numOutcomes).fill(amountPerOutcome);
            
            const tx = await this.contract.addLiquidity(marketAddress, amounts, {
                gasLimit: 500000
            });
            
            await tx.wait();
            console.log(`Initial liquidity provided to ${marketAddress}`);
            
        } catch (error) {
            console.error('Error providing liquidity:', error);
        }
    }
    
    async monitorAndRebalance(marketAddress) {
        try {
            const pool = await this.contract.pools(marketAddress);
            const reserves = pool.reserves;
            
            // Calculate current distribution
            const totalReserves = reserves.reduce((sum, reserve) => sum.add(reserve), ethers.BigNumber.from(0));
            const distributions = reserves.map(reserve => 
                reserve.mul(100).div(totalReserves).toNumber()
            );
            
            // Check if rebalancing is needed
            const targetDistribution = 100 / reserves.length;
            const needsRebalancing = distributions.some(dist => 
                Math.abs(dist - targetDistribution) > this.rebalanceThreshold * 100
            );
            
            if (needsRebalancing) {
                await this.rebalancePool(marketAddress, reserves, distributions);
            }
            
            // Update quotes
            await this.updateQuotes(marketAddress, distributions);
            
        } catch (error) {
            console.error('Error in monitoring cycle:', error);
        }
    }
    
    async rebalancePool(marketAddress, reserves, currentDistributions) {
        console.log(`Rebalancing pool for ${marketAddress}`);
        
        const targetDistribution = 100 / reserves.length;
        const totalValue = reserves.reduce((sum, reserve) => sum.add(reserve), ethers.BigNumber.from(0));
        
        for (let i = 0; i < reserves.length; i++) {
            const currentPct = currentDistributions[i];
            const targetValue = totalValue.mul(targetDistribution).div(100);
            const currentValue = reserves[i];
            
            if (currentValue.gt(targetValue.mul(110).div(100))) {
                // Too much of this outcome, sell some
                const excessAmount = currentValue.sub(targetValue);
                await this.sellOutcome(marketAddress, i, excessAmount.div(2));
                
            } else if (currentValue.lt(targetValue.mul(90).div(100))) {
                // Too little of this outcome, buy some
                const deficitAmount = targetValue.sub(currentValue);
                await this.buyOutcome(marketAddress, i, deficitAmount.div(2));
            }
        }
    }
    
    async sellOutcome(marketAddress, outcomeIndex, amount) {
        try {
            // Find best outcome to swap to
            const reserves = await this.getReserves(marketAddress);
            let bestOutcome = 0;
            let bestReserve = reserves[0];
            
            for (let i = 1; i < reserves.length; i++) {
                if (i !== outcomeIndex && reserves[i].lt(bestReserve)) {
                    bestOutcome = i;
                    bestReserve = reserves[i];
                }
            }
            
            const minAmountOut = await this.contract.calculateSwapOutput(
                reserves[outcomeIndex],
                reserves[bestOutcome],
                amount
            );
            
            // Apply slippage tolerance
            const minOut = minAmountOut.mul(95).div(100);
            
            const tx = await this.contract.swapOutcomes(
                marketAddress,
                outcomeIndex,
                bestOutcome,
                amount,
                minOut,
                { gasLimit: 300000 }
            );
            
            await tx.wait();
            console.log(`Sold ${ethers.utils.formatEther(amount)} of outcome ${outcomeIndex}`);
            
        } catch (error) {
            console.error('Error selling outcome:', error);
        }
    }
}

// test/PredictionMarket.test.js
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("StablecoinPredictionMarket", function() {
    let market, stablecoin, owner, oracle, user1, user2;
    
    beforeEach(async function() {
        [owner, oracle, user1, user2] = await ethers.getSigners();
        
        // Deploy mock stablecoin
        const MockERC20 = await ethers.getContractFactory("MockERC20");
        stablecoin = await MockERC20.deploy("Mock USDC", "USDC", 6);
        
        // Deploy prediction market
        const StablecoinPredictionMarket = await ethers.getContractFactory("StablecoinPredictionMarket");
        market = await StablecoinPredictionMarket.deploy(
            ethers.constants.AddressZero, // Universe address (mock)
            stablecoin.address
        );
        
        // Mint tokens for testing
        await stablecoin.mint(user1.address, ethers.utils.parseUnits("10000", 6));
        await stablecoin.mint(user2.address, ethers.utils.parseUnits("10000", 6));
    });
    
    describe("Market Creation", function() {
        it("Should create market with valid parameters", async function() {
            const endTime = Math.floor(Date.now() / 1000) + 86400; // 24 hours from now
            const resolutionTime = endTime + 3600; // 1 hour after end
            
            await expect(market.createMarket(
                "Will BTC exceed $50,000 by end of month?",
                ["Yes", "No"],
                endTime,
                resolutionTime,
                300, // 3% fee
                oracle.address
            )).to.emit(market, "MarketCreated");
        });
        
        it("Should reject market with end time in past", async function() {
            const endTime = Math.floor(Date.now() / 1000) - 86400; // 24 hours ago
            const resolutionTime = endTime + 3600;
            
            await expect(market.createMarket(
                "Invalid market",
                ["Yes", "No"],
                endTime,
                resolutionTime,
                300,
                oracle.address
            )).to.be.revertedWith("End time must be in future");
        });
        
        it("Should reject market with excessive fees", async function() {
            const endTime = Math.floor(Date.now() / 1000) + 86400;
            const resolutionTime = endTime + 3600;
            
            await expect(market.createMarket(
                "High fee market",
                ["Yes", "No"],
                endTime,
                resolutionTime,
                500, // 5% fee (above 3% limit)
                oracle.address
            )).to.be.revertedWith("Fee rate cannot exceed 3%");
        });
    });
    
    describe("Market Resolution", function() {
        let marketAddress;
        
        beforeEach(async function() {
            const endTime = Math.floor(Date.now() / 1000) + 1; // 1 second from now
            const resolutionTime = endTime + 1;
            
            const tx = await market.createMarket(
                "Test market",
                ["Yes", "No"],
                endTime,
                resolutionTime,
                300,
                oracle.address
            );
            
            const receipt = await tx.wait();
            marketAddress = receipt.events[0].args.market;
            
            // Wait for resolution time
            await ethers.provider.send("evm_increaseTime", [3]);
            await ethers.provider.send("evm_mine");
        });
        
        it("Should allow oracle to resolve market", async function() {
            await expect(market.connect(oracle).resolveMarket(marketAddress, 0))
                .to.emit(market, "MarketResolved")
                .withArgs(marketAddress, 0);
        });
        
        it("Should reject resolution from non-oracle", async function() {
            await expect(market.connect(user1).resolveMarket(marketAddress, 0))
                .to.be.revertedWith("Only oracle can resolve");
        });
        
        it("Should reject early resolution", async function() {
            // Create new market with future resolution time
            const endTime = Math.floor(Date.now() / 1000) + 86400;
            const resolutionTime = endTime + 3600;
            
            const tx = await market.createMarket(
                "Future market",
                ["Yes", "No"],
                endTime,
                resolutionTime,
                300,
                oracle.address
            );
            
            const receipt = await tx.wait();
            const futureMarketAddress = receipt.events[0].args.market;
            
            await expect(market.connect(oracle).resolveMarket(futureMarketAddress, 0))
                .to.be.revertedWith("Too early to resolve");
        });
    });
    
    describe("Edge Cases and Attack Vectors", function() {
        it("Should handle reentrancy attacks", async function() {
            // Test reentrancy protection in market creation and trading
            // This would involve creating a malicious contract that attempts reentrancy
        });
        
        it("Should handle integer overflow/underflow", async function() {
            // Test with extreme values to ensure safe math
        });
        
        it("Should handle market manipulation attempts", async function() {
            // Test scenarios where users try to manipulate market resolution
        });
    });
});

// Enhanced market with multiple outcome categories
contract MultiCategoryMarket {
    enum CategoryType {
        Binary,      // Yes/No
        Categorical, // Multiple exclusive outcomes
        Scalar       // Numerical range
    }
    
    struct ScalarMarketParams {
        uint256 minValue;
        uint256 maxValue;
        uint256 precision;
        string unit;
    }
    
    function createScalarMarket(
        string memory _question,
        ScalarMarketParams memory _params,
        uint256 _endTime,
        uint256 _resolutionTime,
        address _oracle
    ) external returns (address) {
        // Implementation for scalar markets
        // e.g., "What will be the price of BTC on Dec 31st?"
    }
}

// Advanced oracle with multiple data source verification
class AdvancedOracle {
    constructor() {
        this.dataSources = [
            new CoinGeckoAPI(),
            new BinanceAPI(), 
            new KrakenAPI(),
            new CoinbaseAPI()
        ];
        
        this.minimumAgreement = 0.75; // 75% of sources must agree
    }
    
    async resolveWithConsensus(question, outcomes) {
        const results = await Promise.all(
            this.dataSources.map(source => source.resolve(question, outcomes))
        );
        
        // Calculate consensus
        const outcomeVotes = {};
        results.forEach(result => {
            if (result !== null) {
                outcomeVotes[result] = (outcomeVotes[result] || 0) + 1;
            }
        });
        
        const totalVotes = Object.values(outcomeVotes).reduce((sum, votes) => sum + votes, 0);
        
        for (const [outcome, votes] of Object.entries(outcomeVotes)) {
            if (votes / totalVotes >= this.minimumAgreement) {
                return parseInt(outcome);
            }
        }
        
        // No consensus reached
        return null;
    }
}

// Mobile trading interface with simplified UX
const MobileTradingScreen = ({ marketData }) => {
    return (
        <SafeAreaView style={styles.container}>
            <ScrollView>
                <MarketHeader market={marketData} />
                <PriceChart data={marketData.priceHistory} />
                <QuickTradeButtons 
                    outcomes={marketData.outcomes}
                    onTrade={handleQuickTrade}
                />
                <DetailedMarketInfo market={marketData} />
            </ScrollView>
        </SafeAreaView>
    );
};