Entropy Arcade

Entropy Arcade is a provably fair, on-chain gaming platform that turns randomness into a trustless feature instead of a vulnerability. Each game — whether it’s Plinko, Poker, Mines, or SpinWheel — uses verifiable randomness from Pyth Entropy, ensuring that every outcome is transparent, tamper-proof, and viewable on-chain.

Players connect their wallets, choose a game, and interact directly with our PlinkoEntropy smart contract deployed on Base Sepolia. When a user plays, the contract requests a random sequence from Pyth Entropy, logs the request and fulfillment on-chain, and computes the result deterministically. That means neither the developers nor the frontend can influence results — the chain itself decides the outcome.

The goal is to create an arcade layer for web3 where games can plug into a shared randomness oracle. Future developers could drop in their own games and automatically inherit the same fairness guarantees and payout logic.

In short, Entropy Arcade isn’t just another casino — it’s a verifiable gaming infrastructure where players can finally trust the math.

We built Entropy Arcade with a mix of on-chain randomness, modern frontend tooling, and smooth UX design:

Smart Contracts (Solidity): The core contract, PlinkoEntropy.sol, integrates directly with Pyth Entropy’s Base Sepolia deployment. It handles entropy requests (requestWithCallback), tracks player bets, and maps resolved randomness to in-game results. We optimized gas usage and added replay protection via nonce tracking to prevent duplicate plays.

Frontend (Next.js + TypeScript + Tailwind): The webapp is a clean, modular Next.js 15 project with separate routes for each game. We used Framer Motion for fluid animations and dynamic imports to reduce bundle size. Each game (Plinko, Mines, SpinWheel, Poker) is a React component that visualizes the outcome from the same contract.

Blockchain Integration: All wallet logic (connect, fund, play) runs via ethers.js v6. The funding script (arcade_fund.ts) and contract deployments were done through Hardhat. Base Sepolia was chosen for its fast block times and low gas — perfect for rapid entropy callbacks.

Partner Technology – Pyth Entropy: Pyth’s decentralized entropy stream was the backbone of our project. Instead of mocking randomness locally, we integrated their on-chain entropy provider directly, making every spin, shuffle, and drop verifiable on BaseScan. It gave our arcade real credibility — “provably random” actually means something here.

Design and Experience: The visual theme takes cues from modern arcades — soft neon glows, animated cards, and background imagery that changes per game. All UI is responsive and game cards are built with gradient overlays and hover motion to keep the experience immersive even on static testnet data.

Hacky but cool parts:

We reused a single entropy contract for multiple games — a shared randomness bus.

Implemented fallback auto-refresh for delayed Pyth callbacks to handle Base Sepolia’s network latency.

Added a temporary entropy visualizer that replays the random seed animation so users see the randomness at work.

Building this in under hackathon time constraints required quick iteration and ruthless modularization — one contract, many frontends, one shared entropy backbone.