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.
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 deletedA 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 deletedThe 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:
Testnet token: 3oTHkj8nqn82QkZRHkmUmNBX696nzE1rg1fwPRpemEdz
Testnet token contract: GWghYQoDFEb3osEfigrF7CKdZLWauxC7TwM4jsJyqa23
Mainnet DUSD (for the live game): DYqxCsuDgYsEAJ2ADnimkwNdL7C4xbe4No4so19X9mmd
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:
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.