🎮 Betting Yellow: State Channel PvP Protocol

✅ FULLY WORKING: Real blockchain transactions with 2 wallet popups + instant off-chain gameplay!

Instant off-chain wagers. On-chain settlement. Zero gas per round.

🌐 LIVE: Fully Functional Gaming + Solvency Dashboard

🎮 Play Now: http://localhost:3000 (2 wallet popups + instant gameplay)
📊 View Proofs: http://localhost:3000/solvency (solvency verification dashboard)

✅ Working Features:

✅ Real Blockchain Transactions: MinimalCustody contract on Avalanche Fuji
✅ 2 MetaMask Popups: Deposit at start → 0 popups during gameplay → Withdrawal at end
✅ Real Balance Updates: See actual AVAX balance changes after settlement
✅ Off-Chain Efficiency: 10 instant game rounds with zero gas fees
✅ Solvency Proofs: 1 solvent proof published and verified on-chain
✅ Transaction Hash: 0xc1c6c66e394b6df63a587fa98b63e84d5ccfef27b8ba338053dfd710e864442a
✅ Live Contract: MinimalCustody 0xA29750b8fB8640846C3A05f61DEEB495A6c95A7e

🎬 Quick Demo Links

For Judges & Reviewers:

🎮 TRY IT LIVE - 2 wallet popups + instant gameplay! (after npm run dev)
⛓️ Live MinimalCustody Contract - Deployed & tested Feb 4, 2026
🌐 Public Solvency Dashboard - Verify proofs publicly (Phase 8)
📖 Real Transactions Guide - NEW! How the 2-popup flow works
🔧 Deposit Fix Guide - Troubleshooting real transactions
⚡ Wallet Popup Fix - Off-chain signing explained
🎮 Multi-Player Demo - Session sharing & join match
💻 Frontend Code - Complete Yellow SDK integration with real txs
🔧 Smart Contracts Integration - Real on-chain deposit/withdraw
📊 State Channel Service - Off-chain coordination with local signing
🔐 ZK Proof System - Privacy-preserving solvency verification
📋 Implementation Plan - 8-phase roadmap (100% COMPLETE)

🏆 Yellow SDK Prize Track

✅ What We Built (Achievements)

🚀 Fully Functional State Channels (WORKING WITH REAL TRANSACTIONS!)

✅ Yellow SDK Integration: Complete implementation of @erc7824/nitrolite v0.1.0
✅ Smart Contracts Deployed: MinimalCustody contract live on Avalanche Fuji Testnet
✅ Real On-Chain Deposits: MetaMask popup at game start → 0.01 AVAX deposited → Tx confirmed!
✅ Zero Popups During Gameplay: Off-chain local signing for instant state updates (no MetaMask!)
✅ Real Settlement Transactions: MetaMask popup at game end → withdraw winnings → Tx confirmed!
✅ Real Balance Updates: Wallet balance actually changes after deposit and withdrawal
✅ 2 Wallet Popups Total: Start (deposit) + End (withdrawal) = Perfect Yellow Network flow!
✅ Frontend Migration: Complete UI integration with real transaction tracking
✅ Public Verification: All transactions viewable on SnowTrace explorer
✅ Multi-Player Support: Session sharing with Join Match feature
✅ Tested End-to-End: Full flow verified with 0.01 AVAX deposits + withdrawals

🔗 ERC-7824 Compliance

✅ State Channel Protocol: Full implementation of Yellow Network's state channel standard
✅ EIP-712 Signatures: Structured data signing for off-chain state transitions
✅ Channel Lifecycle: Open → Update (instant) → Close (settle) flow
✅ Allocation Tracking: Real-time balance updates with conservation laws

💡 Novel Innovation

✅ PvP Gaming on Channels: First peer-to-peer wagering demo on Yellow SDK
✅ Zero-Gas Rounds: Players compete without paying gas for each move
✅ Economic Model: Wager amounts adjust instantly off-chain, settle once on-chain
✅ Solvency Proof System: Complete cryptographic proof pipeline (8/8 phases)
✅ Session Discovery: Share session IDs for true peer-to-peer coordination
✅ Demo-First Design: Test Yellow Network flow without testnet setup

🔐 Solvency Proof Pipeline (COMPLETE)

✅ Session Export: CSV/JSON export of liabilities after each match
✅ Merkle Trees: Cryptographic proof of liabilities with O(log n) verification
✅ Reserve Scanner: On-chain balance verification from Avalanche Fuji
✅ ZK Proofs: Privacy-preserving cryptographic commitments proving reserves ≥ liabilities
✅ Full Verification: 9-point verification checklist with commitment validation
✅ On-Chain Publication: Publish proofs to blockchain for public auditability
✅ Public Verification: Anyone can verify proofs via smart contract
✅ Automated Pipeline: Zero-touch proof generation after session close
✅ Real-Time Dashboard: Live proof history with status monitoring
✅ Public Interface: /solvency dashboard for users to verify inclusion proofs

📊 Technical Completeness

✅ Contract Layer: lib/contracts.ts - Deposit, withdraw, balance checking
✅ Service Layer: lib/nitroliteService.ts - WebSocket coordination
✅ UI Components: components/ChannelManager.tsx - User-facing deposit/withdraw
✅ Main App: app/page.tsx - Complete Yellow SDK integration
✅ Network Support: lib/wallet.ts - Auto-switch to Anvil (Chain 31337)

� Latest Features (Feb 2026)

Multi-Player Session Sharing 🎮

Join Match Form: Opponents can join your session using a Session ID
Copy Button: One-click session ID sharing
Cross-Tab Support: Play in separate browser tabs
See: Multi-Player Demo Guide

Demo Mode (No Gas Required!) ⚡

Works Immediately: Test without testnet funds
Fallback Balances: Shows 0.5 ETH for instant demos
Perfect for Judges: Demonstrate Yellow Network flow in seconds
See: No-Gas Demo Mode Guide

Enhanced UX Improvements 🎨

Balance Updates: Automatically reflects session winnings
Faucet Integration: Direct links when wallet has no AVAX
Yellow Proof Panel: Real-time metrics for off-chain actions
Session Tracking: View action count, latency, and settlement tx

�� The Problem: High Gas Costs Kill Gaming UX

The Scenario:

You're playing a PvP wager game. Every round costs gas:

Round 1: Player A wins → $2 gas fee
Round 2: Player B wins → $2 gas fee
Round 3: Player A wins → $2 gas fee
5 rounds = $10+ in gas fees 💸

Traditional Solution (Broken):

Pay gas for every state change
Slow confirmation times
Poor user experience
High barrier to entry

💡 The Solution: Yellow State Channels

What Are State Channels?

State channels enable instant off-chain transactions with on-chain security:

Deposit → Open Channel (1 gas fee) 
    ↓
Round 1, 2, 3... N (0 gas fees - instant!)
    ↓
Close Channel → Settle (1 gas fee)

Result: 2 gas fees total vs. N+2 traditional

The Protocol Flow:

User A & B                    Yellow ClearNode              Custody Contract
    |                                |                             |
    | 1. Deposit ETH               |                             |
    |------------------------------------------------------------>|
    |                                |                         [Lock funds]
    |                                |                             |
    | 2. Open Channel               |                             |
    |------------------------------->|                             |
    |                         [Register channel]                  |
    |                                |                             |
    | 3. Play Round 1 (off-chain)   |                             |
    |<------------------------------>|                             |
    |        Instant update!         |                             |
    |                                |                             |
    | 4. Play Round 2 (off-chain)   |                             |
    |<------------------------------>|                             |
    |        Instant update!         |                             |
    |                                |                             |
    | 5. Close Channel              |                             |
    |------------------------------->|                             |
    |                         [Finalize state]                    |
    |                                |                             |
    |                                | 6. Settle                   |
    |                                |---------------------------->|
    |                                |                    [Unlock funds]
    |                                |                             |
    | 7. Withdraw                    |                             |
    |------------------------------------------------------------>|
    |                                |                     [Transfer ETH]

The Economics:

Gas Saved: 83%+ compared to traditional approach
Speed: Instant updates vs. 12s block times
UX: Feels like web2, secured by web3

🏗️ Architecture

MetaMask Wallet (Anvil - Chain 31337)
    ↓
    | Connect + Auto-switch network
    ↓
Next.js Frontend (app/page.tsx)
    ↓
    | User actions: deposit, create match, play rounds
    ↓
NitroliteService (lib/nitroliteService.ts)
    ↓
    | WebSocket connection
    ↓
Yellow ClearNode (ws://localhost:8001/ws)
    ↓
    | State coordination + EIP-712 signatures
    ↓
Smart Contracts (lib/contracts.ts)
    ↓
    | On-chain operations
    ↓
Custody Contract (Anvil Blockchain)
    ↓
    | Lock/unlock ETH
    ↓
Settlement Transaction
    ↓
    | Final state recorded on-chain
    ↓
User receives payout

💻 Core Code

State Channel Opening

File: lib/nitroliteService.ts

async openChannel(participants: string[], initialDeposits: Record<string, string>): Promise<ChannelState> {
  const channelId = this.generateChannelId(participants);
  
  this.currentChannel = {
    channelId,
    participants,
    allocations: initialDeposits,
    nonce: 0,
    status: 'opening',
  };

  // Register with ClearNode
  const response = await this.sendRequest('open_channel', {
    channel_id: channelId,
    participants,
    initial_state: {
      allocations: initialDeposits,
      nonce: 0,
    },
  });

  this.currentChannel.status = 'active';
  return this.currentChannel;
}

→ View full service

On-Chain Deposit

File: lib/contracts.ts

export async function depositToChannel(amountEth: string): Promise<ethers.ContractTransactionResponse> {
  const signer = await getSigner();
  const addresses = getContractAddresses();
  
  const custody = new ethers.Contract(
    addresses.custody,
    CUSTODY_ABI,
    signer
  );

  const amountWei = ethers.parseEther(amountEth);
  
  const tx = await custody.deposit({ value: amountWei });
  await tx.wait();
  
  return tx;
}

→ View full contracts integration

Off-Chain State Update

File: app/page.tsx

const handleSubmitRound = async (winner: string) => {
  const { playerA, playerB, allocations } = currentSession;
  const roundAmount = '0.01'; // 0.01 ETH per round
  
  // Calculate new allocations (instant, no gas!)
  const newAllocations = {
    [winner]: (parseFloat(allocations[winner]) + parseFloat(roundAmount)).toFixed(4),
    [loser]: Math.max(0, parseFloat(allocations[loser]) - parseFloat(roundAmount)).toFixed(4),
  };
  
  // Submit state update via Yellow SDK (off-chain)
  await service.updateState(newAllocations);
  
  addLog('info', `✅ Round ${round + 1} confirmed. Winner: ${winner}`);
};

→ View full frontend

🚀 Deployed Contracts & Solvency System

🔺 Avalanche Fuji Testnet (Live Deployment)

Network: Avalanche Fuji Testnet
Chain ID: 43113 (0xA869)
RPC: https://api.avax-test.network/ext/bc/C/rpc
Explorer: https://testnet.snowtrace.io/
Faucet: https://faucets.chain.link/fuji
Deployment Date: January 31, 2026

Contract	Address	Status	Purpose
MinimalCustody	`0xA29750b8fB8640846C3A05f61DEEB495A6c95A7e`	✅ LIVE & TESTED	Holds user AVAX deposits (deployed Feb 4, 2026)
Adjudicator	`0x44b43cd9e870f76ddD3Ab004348aB38a634bD870`	✅ Live	Dispute resolution (legacy)
SolvencyVerifier	`0x2bFa3B66608C1B1aCF0F8a370c2bA809BE5fa4E2`	✅ Live	On-chain proof verification

ClearNode Coordinator: ws://localhost:8001/ws (local development)

🔗 Contract Verification

View on SnowTrace: https://testnet.snowtrace.io/address/0x44b43cd9e870f76ddD3Ab004348aB38a634bD870

Quick Test:

# Check contract code
curl -X POST https://api.avax-test.network/ext/bc/C/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_getCode","params":["0x44b43cd9e870f76ddD3Ab004348aB38a634bD870","latest"],"id":1}'

Integration: lib/contracts.ts - Deposit, withdraw, balance checking

� Solvency Proof Outputs

For each gaming session, the system automatically generates:

solvency/epochs/<epoch-id>/
├── session.json                 # Session metadata
├── liabilities.csv             # User balances snapshot
├── merkle_root.txt             # Cryptographic root hash
├── merkle_metadata.json        # Tree structure + total liabilities
├── inclusion_<address>.json    # Per-user Merkle proofs (N files)
├── reserves.json               # On-chain reserve scan
├── proof.json                  # ZK solvency proof
├── publicSignals.json          # Public verification data
└── witness.json                # Private audit trail

Key Features:

🌳 Merkle Trees: O(log n) verification with inclusion proofs
💰 Reserve Scanner: Automated balance checking from Avalanche
🔐 ZK Proofs: Privacy-preserving commitments proving solvency
✅ Verification: 9-point checklist with cryptographic validation

�📍 Deployment Information

Complete deployment guide: AVALANCHE_DEPLOYMENT.md
Deployment script: scripts/deploy-avalanche-fixed.js

Contracts are already deployed! Use the addresses above in your .env file.

To redeploy (if needed):

# 1. Get testnet AVAX from faucet
# Visit: https://faucets.chain.link/fuji

# 2. Set your private key
export PRIVATE_KEY="0xYourPrivateKey"

# 3. Deploy contracts
node scripts/deploy-avalanche-fixed.js

# 4. Copy deployed addresses to .env

Verify Your Transactions:

# All transactions are public on SnowTrace
# Visit: https://testnet.snowtrace.io/
# Search for your wallet address or transaction hash

🎯 Why Avalanche?

⚡ Fast: ~2 second block times (vs 12s on Ethereum)
💰 Cheap: Low gas fees (~$0.01 per transaction)
🔗 EVM Compatible: Works with existing Ethereum tools
🌐 High Throughput: 4,500+ TPS capacity
🧪 Great Testnet: Free AVAX from faucet, SnowTrace explorer

🔜 Additional Networks (Future)

Planned deployments for Phase 6+:

Ethereum Sepolia

Use Case: SolvencyProof registry contract
Purpose: Public ZK proof verification
Status: Planned for Phase 6

Avalanche Mainnet (C-Chain)

Use Case: Production deployment
Chain ID: 43114
Status: After successful Fuji testing

🛠️ Tech Stack

Frontend

Next.js 14 - React framework with App Router
TypeScript 5.0 - Type-safe development
TailwindCSS - Utility-first styling
Lucide React - Modern icon library
ethers.js v6 - Ethereum wallet integration

Blockchain

Yellow SDK (@erc7824/nitrolite) - State channel protocol
viem v2 - TypeScript-first Web3 client
Foundry - Smart contract development (Anvil, Forge)
MetaMask - Browser wallet provider

Infrastructure

Nitrolite ClearNode - Off-chain state coordinator
Anvil - Local Ethereum development node
PostgreSQL - State persistence layer
Docker Compose - Service orchestration

🚀 Getting Started

Prerequisites

Node.js 18+ and npm
Docker Desktop (for Nitrolite infrastructure)
MetaMask browser extension
WSL2 (if on Windows)

1. Clone & Install

git clone https://github.com/BlockXAI/Betting_Yellow.git
cd Betting_Yellow
npm install

2. Contracts Are Already Deployed! ✅

MinimalCustody Contract: 0xA29750b8fB8640846C3A05f61DEEB495A6c95A7e (Deployed Feb 4, 2026)
View on SnowTrace: https://testnet.snowtrace.io/address/0xA29750b8fB8640846C3A05f61DEEB495A6c95A7e

✅ Tested Functions:

✅ Deposit: 0.01 AVAX deposited successfully
✅ Withdrawal: 0.005 AVAX withdrawn successfully
✅ Balance tracking works perfectly

No deployment needed - just configure your .env file with the address above!

If you want to deploy your own contract:

# Compile contract
npx solcjs --bin --abi contracts/MinimalCustody.sol --optimize -o build/

# Deploy to Avalanche Fuji
node scripts/deploy-minimal-custody.js

Deployment scripts:

scripts/deploy-minimal-custody.js - Recommended deployment script
contracts/MinimalCustody.sol - Source code

2b. Set Up ClearNode (Optional - Local Development)

cd ~/nitrolite

# Start ClearNode + Database only
sudo docker-compose up clearnode database

Expected output: ClearNode running on port 8001

3. Configure Environment

Update .env with the deployed contract addresses:

# Avalanche Fuji Testnet
NEXT_PUBLIC_RPC_URL=https://api.avax-test.network/ext/bc/C/rpc
NEXT_PUBLIC_CHAIN_ID=43113
NEXT_PUBLIC_CLEARNODE_URL=ws://localhost:8001/ws

# Deployed contract addresses (ready to use!)
NEXT_PUBLIC_CUSTODY_CONTRACT=0xA29750b8fB8640846C3A05f61DEEB495A6c95A7e
NEXT_PUBLIC_ADJUDICATOR_CONTRACT=0x44b43cd9e870f76ddD3Ab004348aB38a634bD870
NEXT_PUBLIC_VERIFIER_CONTRACT=0x2bFa3B66608C1B1aCF0F8a370c2bA809BE5fa4E2

Note: Copy .env.example to .env if it doesn't exist:

cp .env.example .env
# Then update with addresses above

4. Run Development Server

npm run dev

Open http://localhost:3000

5. Test the REAL Transaction Flow 🎮

Expected Flow: 2 MetaMask Popups + Instant Gameplay!

Connect Wallet → MetaMask will prompt to add Avalanche Fuji
Get Test AVAX (if needed):
- Visit: https://faucets.chain.link/fuji OR https://faucet.avax.network/
- Request 0.5 AVAX (free)
- You need ~0.012 AVAX total (0.01 deposit + 0.002 gas)
Create Match → Enter opponent address + wager (e.g., 0.01)
- 🔐 POPUP 1: MetaMask asks to deposit!
- Transaction: Deposit 0.01 AVAX to MinimalCustody
- Click "Confirm" → Wait ~3 seconds
- ✅ Deposit confirmed on-chain!
- Channel opens automatically
Play 10 Rounds → Click "I Won" repeatedly
- ❌ ZERO wallet popups! (All off-chain!)
- ⚡ Each round is instant (<100ms)
- Watch Yellow Proof Panel count actions
- See allocations update in real-time
Close Session → Click "Close Session" button
- ⚡ Channel closes (instant, no popup)
- 🔐 POPUP 2: MetaMask asks to withdraw!
- Transaction: Withdraw your winnings from MinimalCustody
- Click "Confirm" → Wait ~3 seconds
- ✅ Settlement confirmed on-chain!
- 💰 Your wallet balance actually changes!
Verify on SnowTrace:
- Check your transactions: https://testnet.snowtrace.io/
- See deposit tx + withdrawal tx
- View contract balance changes

Result: 2 blockchain transactions for 10 game actions = 5x efficiency!

See detailed guides:

📖 Real Transactions Guide - How the 2-popup flow works
🔧 Deposit Fix Guide - Troubleshooting
⚡ Wallet Popup Fix - Off-chain signing explained
🎮 Multi-Player Demo Guide

📚 Documentation

Quick Start Guides

🚀 Yellow Network Quick Start - Start here! Complete demo walkthrough
🎮 Multi-Player Demo - NEW! Two-player session guide
⚡ No-Gas Demo Mode - NEW! Demo without testnet funds
� ClearNode Setup - Local coordinator setup

Deployment & Integration

�🔺 Avalanche Deployment - Deploy contracts to Fuji testnet
📋 Integration Plan - 8-phase roadmap (27-37 hours)
✅ Phase 2 Complete - Session export implementation
✅ Phase 3 Complete - Merkle tree backend
✅ Phase 4 Complete - Reserves scanner
✅ Phase 5 Complete - ZK proof generation
✅ Phase 6 Complete - On-chain verification
✅ Phase 7 Complete - Automated proof publication
✅ Phase 8 Complete - Public verification dashboard

Technical Documentation

📖 Contracts Documentation - On-chain integration
🌐 Service Documentation - Off-chain coordination
🎨 Component Library - UI components
🔧 Nitrolite Setup - Infrastructure setup guide (legacy)

🏆 Why This Protocol Qualifies for Yellow Track

Novel Technical Contribution:

✅ First PvP gaming implementation on Yellow SDK
✅ Complete state channel lifecycle demonstrated
✅ Solvency proof pipeline - Privacy-preserving cryptographic verification
✅ Economic sustainability model with zero subsidies needed

The Innovation:

🎮 State Channels

83% gas savings compared to traditional on-chain gaming
Instant gameplay with off-chain state updates (<100ms)
Production-ready smart contracts deployed on Avalanche Fuji

🔐 Cryptographic Solvency Proofs (NEW)

Privacy-Preserving: Proves reserves ≥ liabilities without revealing exact amounts
Merkle Tree Verification: O(log n) proof size with inclusion proofs for each user
Commitment Scheme: Cryptographic commitments using keccak256 hashing
On-Chain Scanning: Automated reserve verification from custody contract
Full Pipeline: 5 phases implemented (Session Export → Merkle → Reserves → ZK Proof)

Why This Matters:

Traditional exchanges suffer from opacity - users must trust the platform holds sufficient reserves. Our system provides:

🔍 Transparency: Public verification of solvency
🔐 Privacy: Exact balances remain confidential
📊 Auditability: Anyone can verify proofs independently
⚡ Automated: Proof generation after every session
Extensible architecture for solvency proofs (Phase 2-8)

Technical Excellence:

Full Yellow SDK integration with @erc7824/nitrolite
EIP-712 compliant signatures for state transitions
Proper channel lifecycle management
Real on-chain settlement transactions
Clean separation of on-chain (deposits/settlement) vs off-chain (gameplay)

Try It Live - Public Dashboard (No Setup Required!):

npm install
npm run dev
# Navigate to http://localhost:3000/solvency

What you'll see:

✅ Real proof data from Avalanche Fuji blockchain
✅ 1 solvent proof (250% reserves-to-liabilities ratio)
✅ Search and filter functionality
✅ Inclusion proof verification
✅ Direct SnowTrace transaction links

Try It Live - Gaming (Requires ClearNode):

Clone repo + run npm install
Configure .env with deployed addresses (already configured)
Start ClearNode: cd ~/nitrolite && sudo docker-compose up clearnode database
Run app: npm run dev
Get test AVAX from faucet: https://faucets.chain.link/fuji
Play actual PvP matches with instant off-chain rounds!

Try It Live - Solvency Proofs:

# Automated pipeline (Phase 7) - Runs all steps automatically
npm run proof:automate epoch_1738525000000  # Complete pipeline
npm run proof:automate                      # Auto-detect latest epoch

# Manual pipeline (individual steps)
npm run merkle:build epoch_1738525000000         # Build Merkle tree
npm run reserves:scan epoch_1738525000000        # Scan on-chain reserves
npm run proof:generate epoch_1738525000000       # Generate ZK proof
npm run proof:verify epoch_1738525000000         # Verify proof off-chain
npm run proof:publish epoch_1738525000000        # Publish to blockchain
npm run proof:verify-onchain epoch_1738525000000 # Verify on-chain

# Auto-detect latest epoch
npm run proof:generate        # Uses most recent session
npm run proof:automate        # Runs complete automated pipeline

Deployed & Working:

✅ REAL BLOCKCHAIN TRANSACTIONS: Full deposit → play → withdraw flow working!
✅ MinimalCustody: 0xA29750b8fB8640846C3A05f61DEEB495A6c95A7e - Deployed & tested Feb 4, 2026
✅ Tested Deposits: 0.01 AVAX deposited and confirmed on-chain
✅ Tested Withdrawals: 0.005 AVAX withdrawn and confirmed on-chain
✅ Real Balance Updates: Wallet balance actually changes after transactions
✅ 2 Wallet Popups: Deposit (start) + Withdrawal (end) = Perfect flow!
✅ Zero Popups During Gameplay: Off-chain local signing for instant updates
✅ SolvencyVerifier: 0x2bFa3B66608C1B1aCF0F8a370c2bA809BE5fa4E2
✅ Live Proof on Chain: Transaction 0xc1c6c66e...
✅ Public Dashboard: http://localhost:3000/solvency - WORKING with real data!
✅ Solvency Pipeline: Complete cryptographic proof system
✅ 8/8 Phases: All phases complete
✅ 1 Solvent Proof: 0.5 AVAX reserves > 0.2 AVAX liabilities (250% ratio)
✅ End-to-end tested: Full flow verified with real AVAX on Avalanche Fuji

🛠️ Development

Project Structure

Betting_Yellow/
├── app/
│   ├── page.tsx              # Main app with Yellow SDK integration
│   └── layout.tsx            # Root layout
├── components/
│   ├── ChannelManager.tsx    # Deposit/withdraw UI
│   ├── Match.tsx             # PvP game interface
│   └── EventLog.tsx          # Real-time event logging
├── lib/
│   ├── contracts.ts          # On-chain operations
│   ├── nitroliteService.ts   # Off-chain coordination
│   ├── wallet.ts             # MetaMask integration
│   └── types.ts              # TypeScript definitions
├── .env                      # Contract addresses + config
└── package.json              # Dependencies

Key Files

State Channel Components

File	Purpose	Lines
`app/page.tsx`	Main app logic with Yellow SDK	~625
`lib/nitroliteService.ts`	State channel service	~365
`lib/contracts.ts`	Smart contract integration w/ demo mode	~181
`components/ChannelManager.tsx`	Deposit/withdraw UI with faucet links	~300
`components/Match.tsx`	Match UI with session sharing	~162
`components/YellowProofPanel.tsx`	Real-time Yellow Network metrics	~190

Solvency Proof System

File	Purpose	Lines
`circuits/solvency.circom`	ZK circuit for solvency proof	~98
`scripts/build-merkle-tree.ts`	Merkle tree generation	~299
`scripts/scan-reserves.ts`	Reserve scanner	~282
`scripts/generate-proof.ts`	ZK proof generator	~440
`scripts/verify-proof.ts`	Proof verifier	~369
`contracts/SolvencyVerifier.sol`	On-chain verifier contract	~254
`scripts/publish-proof.ts`	Publish proof on-chain	~272
`scripts/verify-on-chain.ts`	Verify proof on-chain	~278
`scripts/deploy-verifier.js`	Deploy verifier contract	~209
`lib/proofAutomation.ts`	Automated proof service	~374
`components/ProofHistoryDashboard.tsx`	Proof history UI	~284
`scripts/automate-proof.ts`	Automated pipeline script	~174
`app/api/proof-automation/route.ts`	Automation API	~236
`app/solvency/page.tsx`	Public verification dashboard	~540
`lib/sessionExporter.ts`	Session data export	~124

Total Lines of Code: ~5,400+ (complete system)

🎯 Roadmap: Beyond Phase 1

Current Status: 🎉 ALL PHASES COMPLETE 🎉

Completed Phases:

✅ Phase 1 (4-6hrs): Yellow SDK Frontend Migration - Complete
✅ Phase 2 (2-3hrs): Session State Export to CSV - Complete
✅ Phase 3 (4-5hrs): Build Merkle tree from session data - Complete
✅ Phase 4 (2-3hrs): Scan reserves from custody contract - Complete
✅ Phase 5 (6-8hrs): Generate ZK solvency proofs - Complete
✅ Phase 6 (3-4hrs): Deploy to testnet with on-chain verification - Complete
✅ Phase 7 (2-3hrs): Automate proof publication - Complete
✅ Phase 8 (4-5hrs): Build public verification dashboard - Complete

Progress: 8/8 phases complete (100%) 🎉🎉🎉

See: Integration Plan for full details

📜 License

MIT License - see LICENSE file

👥 Team

Built for Yellow Network hackathon by BlockXAI

GitHub: @BlockXAI
Project: Betting_Yellow

🤝 Contributing

Contributions welcome! See Integration Plan for roadmap.

⚡ Built with Yellow SDK • Powered by State Channels • Secured by Ethereum

Name		Name	Last commit message	Last commit date
Latest commit History 24 Commits
app		app
artifacts		artifacts
circuits		circuits
components		components
contracts		contracts
deployments		deployments
lib		lib
nitrolite		nitrolite
scripts		scripts
solvency		solvency
.env		.env
.env.example		.env.example
.gitignore		.gitignore
NO_GAS_DEMO_MODE.md		NO_GAS_DEMO_MODE.md
README.md		README.md
deployed-addresses.txt		deployed-addresses.txt
docker-compose.yml		docker-compose.yml
mock-server.js		mock-server.js
next.config.js		next.config.js
package-lock.json		package-lock.json
package.json		package.json
postcss.config.js		postcss.config.js
start-nitrolite.sh		start-nitrolite.sh
tailwind.config.js		tailwind.config.js
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation