Baultro

Baultro is a multiplayer platform that is both an AI game and a prediction market, offering an innovative approach to competitive gaming with economic incentives on the Electroneum blockchain.

Comment

Baultro - Devpost Submission

Inspiration

The inspiration for Baultro came from observing how AI, gaming, and blockchain technologies were evolving separately but rarely combined effectively. I wanted to create a game where:

  1. AI isn't just a backend tool but the central gameplay mechanic
  2. Blockchain provides real economic stakes rather than just tracking points
  3. Social engineering and conversation skills become a valued gaming ability

Electroneum was the perfect blockchain for this concept because of its low transaction fees and fast block finality (5 seconds), which allows for near real-time game outcomes without breaking the player experience.

What it does

Baultro is an AI-powered gaming platform where players interact with AI \"vaults\" through conversation. Each vault is guarded by an AI personality that players must outsmart to win tokens staked in the vault.

The platform offers four distinct game modes:

  1. Battle Mode: Players try to hack into an AI security system using social engineering
  2. Love Mode: Players attempt to make an emotionally-restricted AI express romantic feelings
  3. Mystery Mode: Players extract a secret phrase hidden within the AI's knowledge
  4. Raid Mode: Players create vaults with stakes that other players try to break into

All game outcomes and stakes are managed on the Electroneum blockchain, with smart contracts handling the prediction markets, match creation, and token distribution.

How we built it

Frontend

  • Next.js 15 with App Router for the application framework
  • React 19 for UI components and state management
  • Tailwind CSS for styling
  • viem for type-safe Electroneum contract interactions

AI Integration

  • Google Gemini API for AI conversations
  • Custom system prompts for each game mode and difficulty level
  • Server-side API integration to protect API keys

Smart Contracts

  • Two primary Solidity contracts deployed on Electroneum testnet:
    • BaultroFinal.sol: Handles the prediction market functionality
    • BaultroGames.sol: Manages game modes like battles and raids
  • ANKR Premium API for reliable RPC connections

Development Workflow

  • Bun for package management and builds
  • Local testnet for initial contract testing
  • Electroneum testnet for final deployment

Challenges we ran into

  1. Smart Contract Complexity: Balancing gas efficiency with complex game logic was challenging. Early versions of the contracts had functions that consumed too much gas. I had to refactor to optimize storage and compute patterns.

  2. Verifying AI Outcomes: Since AI responses can be subjective, creating a reliable way to verify when a player has \"won\" against the AI required multiple approaches:

    • Pattern matching in responses
    • AI self-evaluation of its security breach
    • Hybrid verification system for edge cases

  3. Cross-chain Migration: The project was initially built for another chain, and migrating to Electroneum required updating all contract interactions and wallet providers. Finding documentation on some Electroneum-specific features was occasionally challenging.

  4. AI Reliability: The AI models sometimes responded inconsistently to similar inputs, which made gameplay testing difficult. I needed to create a robust system of prompts and evaluation criteria to ensure consistent gaming experiences.

Accomplishments that we're proud of

  1. Successfully deployed and verified smart contracts on Electroneum testnet
  2. Created a smooth integration between AI gameplay and blockchain verification
  3. Built an intuitive user interface for a complex technical concept
  4. Implemented a multi-mode gaming platform with a single codebase
  5. Optimized contract gas usage for affordable gameplay on Electroneum

What we learned

Smart Contract Development

The development of the Baultro contracts taught me several important lessons:

  1. Storage Optimization: Electroneum, like other EVM chains, makes storage operations expensive. I learned to minimize on-chain data by:
    • Using packed structs (e.g., using uint64 instead of uint256 where possible)
    • Storing only critical verification data on-chain
    • Using events for historical data not needed for contract execution
// Example from BaultroFinal.sol
struct Prediction {
    uint64 id;                  // Using uint64 instead of uint256 to save gas
    address creator;
    string title;
    string description;
    string[] options;
    uint256 stake;
    uint256 totalBets;
    int8 resolvedOption;        // Using int8 with -1 as unresolved state
    uint64 createdAt;           // Timestamps as uint64 saves gas
    uint64 resolvedAt;
}
  1. Permission Patterns: Implementing proper access controls without excessive gas costs:
// Example permission check from resolvePrediction function
require(
    predictions[predictionId].creator == msg.sender || 
    owner == msg.sender,
    \"Only the prediction creator or contract owner can resolve predictions\"
);
  1. Event Emissions: Using events efficiently for off-chain tracking:
// Event definition for tracking prediction creation
event PredictionCreated(
    uint64 indexed predictionId,
    address indexed creator,
    string title,
    uint256 stake
);
  1. Gas-efficient Loops: Handling array operations without excessive gas:
// Example of gas-efficient pagination from getPredictions
function getPredictions(uint64 fromIndex, uint64 limit) public view returns (Prediction[] memory) {
    uint64 resultSize = uint64(min(limit, predictionsCount - fromIndex));
    Prediction[] memory results = new Prediction[](resultSize);

    for (uint64 i = 0; i < resultSize; i++) {
        results[i] = predictions[fromIndex + i + 1];
    }

    return results;
}

Electroneum-Specific Knowledge

  1. Working with Electroneum's 5-second block finality required rethinking UI patterns for transaction confirmations
  2. Learned how to properly verify contracts on Electroneum's block explorer
  3. Discovered the importance of ANKR API for reliable RPC connections

What's next for Baultro

  1. Complete Multiplayer Implementation: Finish and test player vs. player functionality
  2. Mainnet Deployment: Move from testnet to Electroneum mainnet once testing is complete
  3. Mobile Apps: Develop native mobile applications for broader accessibility
  4. AI Personality Editor: Allow players to create and share their own AI vault personalities
  5. Backend Development: Build a scalable backend in Elixir for improved performance and monitoring
  6. Community Building: Create tournaments and events to build a player community

With Electroneum's fast transaction times and low fees, Baultro can become an accessible and engaging platform for combining AI gameplay with real economic stakes.`

Built With

Share this project:

Updates