ETH Arcade

Demo

About

ETH Arcade is an open-source handheld console and SDK for games powered by live financial markets. It turns the ETH price chart into something you can physically interact with: a screen, a rotary knob, two buttons, and a speaker, all housed in a custom enclosure powered by a Raspberry Pi. Our first game is **Box Run**. The player turns the knob to position a box on the price chart and presses a button to commit a stake. Each round lasts ten seconds. If the ETH price finishes inside the box, the player scores a hit and receives the corresponding payout; otherwise, the stake is lost. The market supplies the movement, making every round different. We built ETH Arcade to explore what happens when interacting with crypto becomes tactile, playful, and social. Instead of watching charts across multiple monitors, players can pick up a handheld, learn the controls, and pass it to a friend. Three integrations power the experience: **The Graph supplies the live market data.** We compose Uniswap v3 and v4 Substreams packages into a reusable price pipeline that runs across Arbitrum and Base. Standardized subgraph queries discover supported liquidity pools, while the price consumer filters outliers and calculates a liquidity-weighted ETH price. This connects actual onchain trading activity to gameplay. **Circle’s Arc provides USDC session settlement.** On Arc testnet, players fund a session with USDC. An escrow contract locks the player’s funds alongside a house reserve, and cashing out settles the final session balance back to the player. Gameplay rounds run offchain, keeping the controls responsive, while session funding and settlement happen onchain. Gas is also paid in USDC. The designated device reports the final balance; the contract enforces authorization, payout limits, and refund conditions. **ENSv2 provides player identity and the leaderboard.** On Sepolia, players receive wallet-owned subnames under `tick.eth`. ENSv2’s Enhanced Access Control separates profile permissions from score permissions: players can update their profiles, while a scorekeeper updates designated statistics after observing settled sessions on Arc. The handheld reads names and statistics from ENS records to construct the leaderboard, without a separate leaderboard database. ETH Arcade also includes a **Python SDK** that packages reusable components for price feeds, rounds, odds, wallets, settlement, physical inputs, and sound. Developers can scaffold a game and build their own market-driven experiences using these building blocks. Box Run demonstrates the concept; the SDK makes it extensible. The website brings everything together with an interactive 3D hardware walkthrough, a playable browser version of Box Run, hosted SDK documentation, integration explanations, source links, and our launch video. The browser demo uses simulated prices and paper balances; the integrated onchain flow currently uses testnets. ETH Arcade combines hardware, live blockchain data, stablecoin settlement, and programmable identity into a working arcade experience—and opens the tools for others to build what comes next.

How it's made

We built ETH Arcade from the hardware up. We wanted to take a live ETH chart off a trading dashboard and put it into something you could hold, play, and pass to a friend. That meant building a physical console alongside the game, contracts, data pipeline, and SDK. **Building the handheld** We borrowed a friend’s 3D printer to make the enclosure. That was a very hands-on part of the project: translating a digital design into a shell that had to fit the electronics, expose the controls, and feel comfortable to use. Inside is a Raspberry Pi Zero W connected to a 3.5-inch 480×320 display, a rotary encoder, two buttons, and a rear speaker. The hardware design also includes a lithium-ion battery and charging circuit. We had to account for mounting points, component clearances, display connections, and space for wiring—not just how the outside looked. The controls shaped the game itself. Turning the knob positions a box on the price chart; pressing a button commits the stake. We wanted the interaction to be understandable through your hands, with sound and immediate visual feedback making each action feel like an arcade input. **Firmware and game software** The Python firmware brings together rendering, physical inputs, sound, networking, and the different screens: funding, gameplay, cash-out, receipts, and the leaderboard. Our first game, Box Run, uses ten-second rounds. Players position a price interval and commit a stake. If the ETH price finishes inside the box, they receive the corresponding payout; otherwise, they lose the stake. A key architectural decision was keeping the game loop local. Individual rounds do not wait for blockchain transactions. Funding and settlement happen at session boundaries, so the controls stay responsive while the money flow remains connected to onchain contracts. **The Graph: making the market move the game** We compose Pinax’s Uniswap v3 and Uniswap v4 Substreams packages into a custom `map_pool_prices` module. This reuses existing event decoding and produces a common representation of pool price, liquidity, and block time. The same compiled module runs on Arbitrum and Base with different pool configurations. We also use a shared Messari standardized DEX subgraph query to discover pool metadata for supported Uniswap v3 and SushiSwap v3 deployments. A relay sends live updates to the price consumer, which rejects outliers more than 0.5% from the weighted median and calculates a liquidity-weighted aggregate. This helps keep one thin or stale pool from dominating a round. The Graph is effectively the connection between onchain trading activity and what moves across the handheld’s screen. **Circle and Arc: replacing arcade coins with USDC** We wrote a Solidity escrow contract, `TickEscrow`, and deployed it to Arc testnet. The player funds the device with USDC, and the device opens an escrow session in the player’s name after retaining a configured gas allowance. The contract locks the session funds alongside a house reserve. Rounds execute offchain. At cash-out, the device submits the final balance and the contract settles to the recorded player address. The contract enforces authorization, payout limits, reserve constraints, and a timeout-based reclaim path. Arc lets us use USDC for both session balances and gas. The device is trusted to report the final session balance; the contract does not independently verify every gameplay round. **ENSv2: an arcade identity that holds your score** On Sepolia, we deployed an ENSv2 `UserRegistry` under `tick.eth` and a shared `PermissionedResolver` through ENS’s `VerifiableFactory`. Players receive wallet-owned subnames. Enhanced Access Control separates permissions: players can edit their profile records, while the scorekeeper can update seven designated `tick.*` statistics records. A deterministic Python scorekeeper watches settled sessions on Arc and writes the resulting statistics to ENS. The handheld discovers registered names and resolves their records through the Universal Resolver to construct the standings. One particularly unusual choice is that the leaderboard has no separate application database. ENS stores the player statistics, including a reference to the latest Arc settlement, connecting the payment flow to the player’s arcade identity. **Making the hardware reusable through an SDK** We packaged reusable game infrastructure into a Python SDK: price feeds, rounds, odds, wallets, settlement, physical inputs, and sound. Developers can start with `tick new mygame` and build their own market-driven games. The goal is for someone else to spend their time designing a game rather than rebuilding the connection between a knob, a price feed, a wallet, and a leaderboard. The website uses React, TypeScript, Vite, Three.js, and React Three Fiber to show the hardware through an interactive 3D walkthrough. It also includes a simulated browser version of Box Run, hosted SDK documentation, and our launch video. Firebase Hosting serves the website, and Firestore stores email signups. The most memorable part of building ETH Arcade was bringing all those layers into one physical object: borrowing a friend’s printer, fitting electronics into a custom shell, wiring real controls, and making a live market respond on a tiny screen.