About the project

A game you can audit

RPSLS is peer-to-peer Rock, Paper, Scissors, Lizard, Spock built on Dash Evolution — the data blockchain that powers Dash. Stakes are real DUSD, moves are cryptographically committed, and every settlement is an on-chain document you can re-verify yourself. This page explains how it all works — especially the data contracts.

▶ Verify fair play yourself Watch the Demo Watch Party

The rules, in one breath

Both players stake 1.00 DUSD. The pot is 2.00. The winner takes 1.88× their stake — the pot's 1.98 minus the 0.10 on-chain platform cost the winner funds, which buys the network credits every match burns — and The House keeps 1% of the pot (0.02 DUSD) — on wins only. A draw is a push: both stakes return in full and both players are re-queued against new opponents (pushes never pay a fee). No house bankroll — players pay players.

1 · Commit both players seal sha256(move ‖ salt) 2 · Reveal moves open — the commits prove they never changed 3 · Settle an immutable result document pays the winner on-chain

The game logic is the canonical Sam Kass / Big Bang Theory edge list — one source of truth shared 1:1 by the game client, the house daemon and this site, so all three agree on every edge.

Dash Evolution, in six ideas

Dash Evolution is a data layer on the Dash network: masternodes store structured data, reach consensus on it, and serve it with cryptographic proofs. Six building blocks are all you need to follow the rest of this page.

Identity

An on-chain account with its own keys — players, bots and The House each have one. Identities hold credit balances (prepaid compute) and DUSD token balances.

Data contract

A JSON schema registered on-chain by an identity. Think of it as a database table definition anyone can read — and nobody can silently change: the fields, types and indices are pinned by the contract owner's signature.

Document

A row that conforms to a data contract — a challenge, a result, a profile. Every write is a signed state transition, ordered by nonces, confirmable by proofs.

DPNS name

Dash Platform Name Service — human names like rpsls-platform-referee-v2.dash, each linking a name to an identity. Our cast and The House are reachable by name.

Token

DUSD is a Dash Platform token: 6 decimals, one supply, transfers signed by identity keys. Stakes and payouts move as token transfers between identities.

Proofs

Queries can return cryptographic proofs, so a light client (or your browser) can verify an answer against the chain — the fair-play verifier uses the same documents your browser can re-check.

Our data contract — the whole game, three tables

Everything RPSLS does on-chain lives in ONE data contract on the Dash testnet, owned by The House (rpsls-platform-referee-v2.dash):
EvCyNsq874kf8jGRhHFjvbnnmXE5DmebyqLE9PYrKgRF

A data contract is just a JSON schema — fields, types, value ranges and indices — registered on-chain. Once registered it pins the shape of every document that follows. Here is the entire contract, document type by document type, exactly as the schema defines it:

profile

immutable · cannot be deleted

A player's public card: display name and lifetime counters.

displayName string, 3–32 chars — the name shown in the theater
wins / losses / pushes integer counters, one row per player
createdAt ms timestamp

Indices: wins-asc — leaderboard queries sort by wins

challenge

mutable (the state field advances)

The match itself — created by The House once two players are paired.

player1Id / player2Id 32-byte Dash identity references (the players)
stake integer, base units — 1000000 = 1.000000 DUSD each
state OPEN → COMMITTED → REVEALED → SETTLED / PUSHED
commit1 / commit2 sha256(move ‖ salt) as hex — the sealed moves
move1 / move2 0–5 (0 = not revealed yet, 1–5 = the move)
createdAt ms timestamp

Indices: by-state, by-player1, by-player2 — matchmaking and history queries

result

immutable · cannot be deleted

The settlement receipt — written once, by The House, after reveal.

challengeId 32-byte link back to the challenge
winnerId the winner's identity — or the all-zeros sentinel 111111111111… when nobody won (push)
winningMove / losingMove 0–5, the revealed moves
fee / payout house fee and winner payout, in DUSD base units
settledAt ms timestamp

Indices: by-challenge — UNIQUE, one result per challenge, ever

Why this shape is the game: challenge.state is the match's life so anyone can see where a game stands; commit1/commit2 make the moves un-fakeable (you can't change a move after seeing yours — the hash would stop matching); and result is immutable with a unique per-challenge index, so a settlement can never be rewritten or duplicated. The all-zeros winner sentinel exists because the platform requires identifiers to be exactly 32 bytes — "no winner" gets a real value instead of an empty field.

DUSD — the stake currency

Stakes and payouts are Dash Platform tokens: one supply, 6 decimals, transfers signed by identity keys. You can watch the demo's token live on the public explorer:

The Demo Watch Party plays with house-funded testnet DUSD. Human play uses REAL stakes — players fund DUSD through the upcoming DASH→DUSD exchange, and the live game runs on mainnet.

Names — who is who on-chain

Every identity in the game has a DPNS name, so leaderboards and the theater show names instead of opaque ids:

The House: rpsls-platform-referee-v2.dash

The demo cast: RPSLS-QuantumExplorer-DemoBot.dash, RPSLS-Pasta-DemoBot.dash, RPSLS-DesertLynx-DemoBot.dash, RPSLS-Pshenmic-DemoBot.dash

DPNS itself is a system data contract — you can read its schema on the explorer too: the DPNS contract. Display policy: a username is shown only once it actually resolves on-chain; until then you see a short identity id. No fake names.

Signing in — App Connect, explained

The live game signs you in with the DashPay mobile app via App Connect, a Dash protocol for wallet-based app login. The flow, in four steps:

1 · Request the app mints a one-time key pair and shows a QR code 2 · Approve your wallet shows exactly what is granted — bounded keys, a spending budget, an expiry 3 · Register the wallet registers those session keys on your identity (you keep the master keys) 4 · Response an encrypted loginKeyResponse lands on the App Connect system contract — only the app can decrypt it

The response lives on a SYSTEM contract shared by every app (H8F9mP1BM55TE1ShsxPZHzhyinaMdY9bMmP85mkDhcJJ). The keys your wallet grants are bounded to our contract, capped by a credit budget and an expiry date — the app never holds your master key, never touches your wallet balance, and the grant dies on schedule even if we disappeared tomorrow.

The House — custodian, not casino

A trusted house daemon holds stakes in escrow, pairs opponents, reveals moves and settles. It has no web endpoint and publishes everything it depends on: commits go on-chain before moves exist, reveal salts are published at /fairplay, and every settlement is an immutable result document. In the Demo Watch Party, house fees recycle: when a knockout tournament ends, the pool is reseeded into fresh stacks and the next tournament starts — the house keeps nothing.

Demo now, live next

Today, demo.rpsls.app runs a labeled bot cast — four automated players with their own usernames, fighting knockout tournaments on testnet, ledgered at /tournaments. It is explicitly a demo: no real players, no real money.

Next: LIVE human play — real-stake PvP, human identities through the DashPay mobile app (App Connect) or the Dash browser extension, matchmade only against other humans. No house bots in the human flow.

Open source

The whole stack — game client, house daemon, read-only API, this site and the data contract schemas — is being released as open source. Fork the contract, deploy your own House, audit every line. If you can read JSON, you can read the rules of this game.