Betlify.fun: Cross-Chain Prediction Markets Builder on Solana

Decentralized prediction markets with seamless cross-chain interoperability

Betlify.fun is a no-code prediction market platform that enables anyone to create, participate in, and profit from custom prediction markets. Built on Solana with LayerZero v2 OApp integration, it provides true cross-chain functionality allowing users from any blockchain to participate seamlessly.

Click the image to watch the Demo

🎯 Core Concept

Unlike traditional prediction markets that restrict users to curated markets, Betlify.fun empowers individuals to create markets around any topic or event. Market creators earn a percentage of pool funds, incentivizing high-quality, engaging markets. The platform's cross-chain architecture breaks down blockchain silos, opening up liquidity and participation from across the entire ecosystem.

🔄 Cross-Chain Architecture Flow

                                    ┌─────────────────┐
                                    │   Betlify.fun   │
                                    └─────────┬───────┘
                                              │
                                              ▼
                                    ┌─────────────────┐
                                    │  User Actions   │
                                    │ Create Pool, Place Bet, Claim Winnings │
                                    └─────────┬───────┘
                                              │
                                              ▼
                    ┌─────────────────────────────────────────────────┐
                    │                                                 │
                    ▼                                                 ▼
            ┌─────────────────────┐                         ┌─────────────────────┐
            │ EVM Users           │                         │ Solana Users        │
            │ (Ethereum, Polygon, etc.)                     │                     │
            └─────────┬───────────┘                         └─────────┬───────────┘
                      │                                                 │
                      ▼                                                 ▼
            ┌─────────────────────┐                         ┌─────────────────────┐
            │ Borsh Serialization │                         │ Betlify Solana      │
            └─────────┬───────────┘                         │ Program             │
                      │                                     └─────────────────────┘
                      ▼
            ┌─────────────────────┐
            │ EVM Contract        │
            │ (BetlifyEvm Adapter)│
            └─────────┬───────────┘
                      │
                      ▼
            ┌─────────────────────┐
            │ LayerZero Executor  │
            └─────────┬───────────┘
                      │
                      ▼
            ┌─────────────────────┐
            │ Betlify Solana      │
            │ Program             │
            └─────────────────────┘

🏗️ Technical Architecture Deep Dive

🦀 Rust/Anchor Smart Contracts

The core of Betlify.fun is built with Rust and the Anchor framework, providing type-safe, efficient smart contracts on Solana.

Program Structure

programs/my_oapp/src/
├── lib.rs                    # Main program entry point
├── instructions/             # Core betting logic
│   ├── create_pool.rs        # Market creation with PDA
│   ├── place_bet.rs          # Bet placement with validation
│   ├── resolve_market.rs     # Market resolution
│   ├── claim_winnings.rs     # Payout processing
│   └── lz_receive.rs         # Cross-chain message handler
├── state/                    # Account data structures
│   ├── bet_pool.rs           # Pool state management
│   ├── bet.rs                # Individual bet tracking
│   ├── store.rs              # Global program state
│   └── peer_config.rs        # LayerZero peer configuration
└── msg_codec.rs              # Anchor serialization/deserialization of BetlifyMessage

📨 Cross-Chain Message Serialization

Borsh Serialization Architecture

Betlify.fun uses Borsh serialization for efficient cross-chain message passing:

#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug, PartialEq)]
pub enum BetlifyMessage {
    CreatePool {
        question: String,
        options: Vec<String>,
        pool_id: u64,
        start_time: i64,
        lock_time: i64,
        end_time: i64,
    },
    PlaceBet {
        pool_id: u64,
        option: u8,
        amount: u64,
    },
    ResolveMarket {
        pool_id: u64,
        winning_option: u8,
    },
    ClaimWinnings {
        pool_id: u64,
    },
}

Frontend Encoding Using Borsh (TypeScript)

To pass structured BetlifyMessage that is compatible with Anchor's Deserialize, we used borsh to encode and serialize messages.

// Borsh schema for CreatePool message
const createPoolSchema = borsh.struct([
  borsh.u8("variant"),
  borsh.str("question"),
  borsh.vec(borsh.str(), "options"),
  borsh.u64("pool_id"),
  borsh.i64("start_time"),
  borsh.i64("lock_time"),
  borsh.i64("end_time"),
]);

// Encode message for cross-chain transmission
export function encodeBetlifyMessage(message: BetlifyMessage): Buffer {
  const buffer = Buffer.alloc(1000);
  schema.encode(data, buffer);
  return buffer.subarray(0, schema.getSpan(buffer));
}

Solana Deserialization

Function to handle deserialization in Betlify Solana Program

// Decode incoming cross-chain messages
pub fn decode_betlify_message(data: &[u8]) -> std::result::Result<BetlifyMessage,        MsgCodecError> {
    BetlifyMessage::try_from_slice(data).map_err(|_| MsgCodecError::InvalidUtf8)
}

// Example using it in the Program's logic
match msg_codec::decode_betlify_message(&params.message) {
    Ok(betlify_msg) => {
        match betlify_msg {
            BetlifyMessage::CreatePool { question, options, pool_id, .. } => {
                // Create new pool with deterministic PDA
                let bet_pool = &mut ctx.accounts.bet_pool;
                bet_pool.id = pool_id;
                bet_pool.question = question;
                // ... initialize pool state
            }
            // ... handle other message types
        }
    }
    Err(err) => return Err(BetlifyError::InvalidMessage.into())
}

🔐 Program Derived Addresses (PDAs)

Betlify.fun leverages deterministic PDAs for efficient account management and cross-chain coordination:

Core PDA Seeds

// Store account - Global program state
seeds = [b"Store"]

// BetPool accounts - Unique per creator and pool ID
seeds = [b"betpool", creator.key().as_ref(), &pool_id.to_le_bytes()]

// Bet accounts - Unique per user and pool
seeds = [b"bet", user.key().as_ref(), bet_pool.key().as_ref()]

// Peer configuration - LayerZero cross-chain setup
seeds = [PEER_SEED, &store.key().to_bytes(), &src_eid.to_be_bytes()]

PDA Benefits

Deterministic Addressing: Predictable account addresses across chains
Gas Efficiency: No need to store account addresses in messages
Cross-Chain Coordination: EVM contracts can derive Solana account addresses
Security: Prevents account collision and unauthorized access

🔗 EVM contract logic to send BetlifyMessages

The EVM contract contains one primary method to send Betlify Messages.

EVM Side (Solidity)

// BetlifyEvmAdapter.sol - Cross-chain interface
contract BetlifyEvmAdapter is Ownable, OApp, OAppOptionsType3 {
    function sendBetlifyAction(
        uint32 dstEid,
        bytes calldata message,
        bytes calldata optionsData
    ) external payable returns (MessagingReceipt memory receipt) {
        bytes memory lzOptions = combineOptions(dstEid, 1, optionsData);
        receipt = _lzSend(dstEid, message, lzOptions, MessagingFee(msg.value, 0), payable(msg.sender));
    }
}

🎨 Frontend Architecture

Modern React + TypeScript frontend with comprehensive cross-chain support:

frontend/client/src/
├── components/                # Reusable UI components
│   ├── market-card.tsx        # Market display component
│   ├── market-carousel.tsx    # Market browsing
│   ├── wallet-connect-modal.tsx # Multi-chain wallet support
│   └── ui/                    # Design system components
├── pages/                     # Main application pages
│   ├── home.tsx               # Market discovery
│   ├── create-market.tsx      # Market creation interface
│   └── bet-details.tsx        # Detailed market view
├── contexts/                  # State management
│   └── WalletContext.tsx      # Multi-chain wallet context
├── hooks/                     # Custom React hooks
├── lib/                       # Contract interactions
│   ├── contracts.ts           # Solana program client
│   ├── encodeBetlifyMessage.ts # Borsh encoding utilities
│   └── solana-contracts.ts    # Solana-specific utilities
└── types/                     # TypeScript type definitions

Deployment details.

Solana OApp Program ID: EzSWvfipsRAQxPspMFm9QVot1jHwAGxKYWtnNi8YFT5R
Solana OApp Address (Store): 7zT3rAb8tNAK8mSewyxRz7ubbDtnXEcSaoJnyVyg4f8n
EVM OApp Address: 0x2ED9929e3AA3CAd3553aA90014894300D3Fa224d
LayerZero Scan: https://testnet.layerzeroscan.com/address/7zT3rAb8tNAK8mSewyxRz7ubbDtnXEcSaoJnyVyg4f8n

🚀 Getting Started

Prerequisites

Node.js 18+
Rust 1.70+
Solana CLI
Anchor CLI

Quick Start

Clone and setup

git clone https://github.com/yourusername/betlify.fun.git
cd betlify.fun

Build Solana programs

cd programs/my_oapp
cargo build
anchor build

Deploy contracts

# Deploy Solana program
anchor deploy

# Deploy EVM adapter
npx hardhat deploy --network <network>

Configure LayerZero endpoints

# Update lib/config.ts with your LayerZero endpoints

Run frontend

cd frontend/client
npm install
npm run dev

🔧 Development

Building and Testing

# Solana program development
anchor build
anchor test

# EVM contract testing
npx hardhat test

# Cross-chain integration testing
cd test/betlify-test
npm run test:cross-chain

Key Development Commands

# Verifiable build with environment variable
anchor build -v -e MYOAPP_ID=<OAPP_PROGRAM_ID>

# Generate client SDK
cd lib && npm run generate

# Deploy to specific networks
npx hardhat deploy --network optimism-testnet
npx hardhat deploy --network solana-testnet

📊 Project Structure

betlify.fun/
├── programs/my_oapp/          # 🦀 Solana smart contracts (Rust/Anchor)
│   ├── src/
│   │   ├── instructions/      # Core betting logic
│   │   ├── state/             # Account data structures
│   │   ├── msg_codec.rs       # Borsh serialization
│   │   └── lib.rs             # Program entry point
│   └── Cargo.toml
├── contracts/                 # 🔗 EVM contracts (Solidity)
│   ├── BetlifyOApp.sol        # Cross-chain adapter
│   └── libs/BetlifyMsgCodec.sol # Message encoding
├── frontend/client/           # 🎨 React frontend
├── lib/                       # 📚 SDK and utilities
│   ├── client/                # Generated Solana client
│   └── scripts/               # Deployment and testing
├── deploy/                    # 🚀 Deployment scripts
├── test/                      # 🧪 Test suites
└── docs/                      # 📖 Documentation

🗺️ Roadmap

Phase 1: Core Platform ✅

Solana smart contracts with PDA architecture
LayerZero v2 OApp integration
Borsh cross-chain message serialization
Basic frontend interface

Phase 2: Enhanced Features 🚧

OFT (Omnichain Fungible Token) integration for cross-chain payouts
Advanced market resolution mechanisms
Dispute resolution system
Community governance features

Phase 3: Ecosystem Growth 📈

Open API for third-party integrations
Mobile app development
Advanced analytics dashboard
Institutional features

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines for details.

Development Guidelines

Follow Rust/Anchor best practices for Solana programs
Use TypeScript for frontend development
Write comprehensive tests for all new features
Document your code and APIs
Ensure cross-chain compatibility

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgements

LayerZero - Cross-chain messaging infrastructure
Anchor - Solana smart contract framework
Solana - High-performance blockchain platform
Borsh - Binary serialization format

Betlify.fun — Own the market. Predict the future. From any chain.

Name		Name	Last commit message	Last commit date
Latest commit History 7 Commits
assets		assets
contracts		contracts
deploy		deploy
deployments		deployments
docs		docs
frontend		frontend
lib		lib
programs/my_oapp		programs/my_oapp
tasks		tasks
test		test
.env.example		.env.example
.eslintignore		.eslintignore
.eslintrc.js		.eslintrc.js
.gitignore		.gitignore
.nvmrc		.nvmrc
.prettierignore		.prettierignore
.prettierrc.js		.prettierrc.js
Anchor.toml		Anchor.toml
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
README.md		README.md
betlify.rs		betlify.rs
buffer-keypair.json		buffer-keypair.json
foundry.toml		foundry.toml
hardhat.config.ts		hardhat.config.ts
layerzero.config.ts		layerzero.config.ts
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
rust-toolchain.toml		rust-toolchain.toml
rustfmt.toml		rustfmt.toml
solhint.config.js		solhint.config.js
tsconfig.json		tsconfig.json

CryptoInnovators/Betlify-x-Layerzero

Folders and files

Latest commit

History

Repository files navigation