PTX will deliver cryptographically verifiable random outputs via a simple API, backed by a decentralised Gamemaster quorum, with every result committed on-chain. No smart contracts. No Solidity. If your game can make an HTTP call, it will use PTX.
PTX separates fast randomness generation from permanent on-chain commitment — so your game gets results instantly, and players get proof forever.
Your game server calls ptx_roll() with your parameters — count, range, unique. One HTTP call. No blockchain knowledge needed.
A decentralised quorum of Gamemaster nodes reaches threshold BLS consensus. Nobody — not Hemis, not the nodes, not your studio — can predict or influence the result.
1–3 secondsYour game receives a verifiable random output with a quorum signature. Use the integers directly or pass the round seed to your procedural generation engine.
The seed, signature, and quorum members are written to the Hemis blockchain. Any player, regulator, or third party can verify every result — now and forever.
~60 seconds · next blockOne call handles everything. For multiplayer sessions, ptx_create_session() gives you the full lifecycle API.
Pass tx_id to any block explorer to independently verify the result. The quorum signature cryptographically binds the output — it cannot be altered after the fact.
PTX is a randomness primitive — not a game engine. What you build with it is entirely up to you.
Roll dice, draw cards, shuffle decks. Every result is on-chain and player-verifiable from session creation.
Seed your map generator or dungeon layout from a verifiable PTX output — players can confirm terrain was generated fairly.
Prove your drop rates on-chain. Real rates emerge from actual session data, not developer-published tables.
Bracket seedings, player matchups, team selection — all provably fair with a shared on-chain seed before the draw.
Trait assignment committed to chain before reveal. Collectors verify their mint was fair from the permanent record.
Winners selected from a verifiable seed. The result is on-chain before you announce it — no trust required.
Roll character attributes at creation with a session seed players can inspect. Stat manipulation is cryptographically impossible.
Reproducible, auditable random samples with a permanent proof of the seed used. Methodology becomes independently verifiable.
Both players contribute to a combined seed — neither side can influence the outcome. Disputes resolved by block explorer link.
The difference between PTX and every other random number service is what happens after the result is delivered.
A server-side RNG your players can't inspect. Rate manipulation is undetectable. Regulators demand internal audit logs. Data miners find inconsistencies and you face a PR crisis.
Every result is cryptographically signed by a decentralised quorum. Manipulation is impossible — the seed determines the outcome. Regulators get a block explorer link, not a self-certification. Data miners verify your rates are correct.
The platform controls the RNG. Players have no way to confirm results. Tournament outcomes can be disputed forever. No recourse, no audit trail.
Players, journalists, and regulators can independently reproduce every outcome from the on-chain seed. Your competitive moat isn't a marketing claim — it's a block explorer link that no competitor can replicate.
Dates beyond Phase 1 are estimates. This page reflects actual completion dates as each phase finishes — not targets we hope are true.
Full PTX architecture locked. 28 Key Design Decisions recorded and closed. 16 Open Design Choices tracked with explicit resolution criteria. API contract finalised. Full design document v3.5 issued. Phase 1 implementation plan issued.
Python simulator with full hash commit-reveal state machine. Adversarial scheduler tests. Output mapping uniformity confirmed. Full NIST SP 800-22 battery passed on the reference C implementation across 640 million bits.
10 hemisd nodes on a single virtualised Proxmox host (CT101–CT110). Modified hemisd binaries with ptx_roll and ptx_getroundstatus RPCs. First time PTX ran on actual node software. Completed ahead of Q3 2026 target.
Results: 109/120 tests passing. 7 bugs fixed (including 2 HIGH severity blockers). Remaining 11 are Phase 2 architectural deferrals — none are regressions.
11-node Docker testnet. Hash commit-reveal replaced by threshold BLS12-381 via supranational/blst — the cryptographic core of PTX. For any given seed and quorum key, exactly one valid output exists. Last-revealer advantage eliminated entirely. Toxiproxy fault injection. Prometheus/Grafana telemetry.
21+ geographically distributed nodes run by independent operators. Full Pedersen DKG. Public block explorer. SDK and API docs released. First real-world measurement of the 1–3 second latency design target under actual network conditions. Developer access opens here.
External operators become the majority of Gamemaster nodes. Session expiry and fee model finalised with real developer data. The 1–3 second latency design target confirmed or revised based on actual production measurement.
Full production launch. ptx_roll() callable by any game developer. n=21+ quorum, t≈67% threshold. Full codebase open-sourced at launch. This is when PTX becomes a real production service.
Three independent test batteries. All exit criteria met. Being clear about the scope is as important as the results.
1,000 rounds per scenario. Does the protocol produce a valid result and correctly penalise misbehaving nodes?
| Scenario | Description | Result |
|---|---|---|
| All honest | All nodes commit and reveal correctly | PASS |
| Single withholder | One node commits but withholds reveal — PoSe penalty applied, round resolves from remaining nodes | PASS |
| Multiple withholders | Multiple nodes withhold — protocol degrades gracefully within threshold | PASS |
| Invalid commitment | Node submits an invalid commitment hash — rejected by protocol | PASS |
| Late reveal | Node reveals after window closes — treated as withhold, PoSe applied | PASS |
| Abstainer | Quorum node does not participate at all — protocol continues without it | PASS |
| Reveal mismatch | Node reveal does not match commitment — rejected, PoSe applied | PASS |
| Threshold boundary | Exactly t nodes honest, n−t withhold — resolves at minimum valid threshold | PASS |
| Below threshold | Fewer than t honest nodes — round correctly declared failed, no result produced | PASS |
χ² tests across all game value mapping types. Rejection sampling and Fisher-Yates both confirmed bias-free.
| Game Type | Mapping Method | Result |
|---|---|---|
| Dice (d6) | Rejection sampling · low=1, high=6 | PASS |
| Dice (d20) | Rejection sampling · low=1, high=20 | PASS |
| 52-card draw | Fisher-Yates shuffle · unique=true | PASS |
| Card draw (no replacement) | Fisher-Yates · unique=true, count=5 · zero duplicates verified | PASS |
| Player selection (pool of 10) | Rejection sampling · count=1, high=10 | PASS |
| Unique player selection (3 of 10) | Fisher-Yates · unique=true, count=3 | PASS |
| Custom range (non-power-of-2) | Rejection sampling · bias test | PASS |
| Large range (1–1000) | Rejection sampling · χ² uniformity | PASS |
| Single value draw | count=1 · χ² uniformity | PASS |
| Multi-value draw (count=10) | 10 independent values · independence + uniformity | PASS |
| Beacon expansion | SHA256 chain expansion · no truncation bias (KDD-024 fix verified) | PASS |
The Python harness reported 3 failures. All were traced to bugs in the Python test code — not the beacon. The same bitstreams passed all 15 tests on the official NIST reference C binary.
| Test | Python Rate | Python | Root Cause (if fail) | Ref C |
|---|---|---|---|---|
| Frequency (Monobit) | 97.0% | PASS | — | REF PASS |
| Frequency within Block | 99.0% | PASS | — | REF PASS |
| Runs | 99.0% | PASS | — | REF PASS |
| Longest Run of Ones | 99.0% | PASS | — | REF PASS |
| Binary Matrix Rank | 100.0% | PASS | — | REF PASS |
| Discrete Fourier Transform | 97.0% | PASS | — | REF PASS |
| Non-overlapping Template | 99.0% | FAIL (KS) | KS p-value edge case in Python chi² aggregation — not a beacon defect | REF PASS |
| Overlapping Template | 100.0% | PASS | — | REF PASS |
| Universal Statistical | 100.0% | PASS | — | REF PASS |
| Linear Complexity | 97.0% | PASS | — | REF PASS |
| Serial | 98.0% | PASS | — | REF PASS |
| Approximate Entropy | 99.0% | PASS | — | REF PASS |
| Cumulative Sums | 97.0% | PASS | — | REF PASS |
| Random Excursions | 92.9% | FAIL | Python cycle detection bug — artificial zero appended, biasing chi-squared. Beacon not at fault. Ref C: 128/128. | REF PASS 128/128 |
| Random Excursions Variant | 95.2% | FAIL (KS) | Same cycle detection bug as above. Ref C: 281/288. | REF PASS 281/288 |
PTX running on actual hemisd node binaries for the first time. 10 regtest nodes. Phase 1 criteria met and closed ahead of the Q3 2026 target.
~1,400 real ptx_roll() calls on live nodes. ~7,000 node-level cryptographic operations. Two full runs: standard suite + adversarial suite.
| Criterion | Tests | Result |
|---|---|---|
| End-to-end PTX flow on real binaries | Full round from API call through commit-reveal to on-chain PTXSESS transaction | T01–T10 · 10/10 |
| BUG-003 fixed — exclude ≥96 no longer crashes | exclude sizes 97, 200, 500, 1000 all succeed — no fixed buffer remains | T101–T104 · 4/4 |
| BUG-004 fixed — zero exclusion violations | 850 iterations across exclude sizes 10–90 — zero violations. P(<10⁻¹⁰) if bug present. | T114–T116 · 3/3 |
| Chi-square uniformity | Coin flip, d6, d20, d100 — all pass at p>0.05 | T39–T42 · 4/4 |
| Game scenarios | Dice, cards, raffle, multi-round chaining | T29–T38 · 10/10 |
| Multi-round game correctness | Card game, depleted deck (47 excluded), 90% excluded density | T117–T120 · 4/4 |
| Concurrent load | Up to 30 simultaneous ptx_roll() calls — no crashes, no corruption | T81–T85 · 5/5 |
| Nonce chaining KDD-015 | Fixed salt across sequential calls produces distinct seeds per round | T96–T98 · 3/3 |
| Adversarial mechanics | Withhold, abstain, PoSe accumulation, recovery — all confirmed on live nodes | T71–T80 · 10/10 |
| Block height anchoring KDD-003 | block_height present in response and consistent with chain state | T92 · PASS |
| Bug | Severity | Description | Status |
|---|---|---|---|
| BUG-001 | FIXED | PTX parser separator @ vs : mismatch | Early Phase 1 · no regression |
| BUG-002 | FIXED | -ptxmynodeid config flag name mismatch | Early Phase 1 · no regression |
| BUG-003 | HIGH · FIXED | exclude ≥96 items → HTTP 500. Exclude pipeline rebuilt with dynamic allocation throughout. | T101–T104 · PASS |
| BUG-004 | HIGH · FIXED | Exclusion fallback returned excluded values ~30% of the time. Replaced with deterministic exhaustive search. | T114–T116 · 850 iterations · zero violations |
| BUG-006 | LOW · FIXED | exclude accepted non-array types silently. Added typed validation at RPC entry. | T59/T60/T62/T63 · PASS |
| BUG-007 | LOW · FIXED | Extra RPC params silently accepted. Added upper bound param count check. | T66 · PASS |
| BUG-008 | LOW · FIXED | Non-hex caller_salt accepted without error. Added hex format validation at RPC entry. | T68 · PASS |
Phase 1 uses hash commit-reveal. The last-revealer advantage is economically deterred by PoSe penalties but not cryptographically eliminated. Threshold BLS12-381 — which eliminates it entirely — is Phase 2.
All 10 nodes are on a single Proxmox host. No real latency, no packet loss, no network partitions. Fault injection is simulated via RPC flag, not real node misbehaviour.
PoSe scores are held in memory only in Phase 1. A node restart clears all penalties. Disk persistence and score decay are Phase 2 items (KDD-028).
Cannot be meaningfully measured on single-host regtest. Signing latency is sub-millisecond on localhost. Real-world latency is first measured in Phase 3 under actual WAN conditions.
| Item | Reason for deferral |
|---|---|
| BUG-005 — P2P round status broadcast | Round status is only visible on the initiating node. Requires a real multi-party testnet to test meaningfully. Phase 1 regtest is single-host. |
| BUG-009/010 — GM role separation + dedicated caller node | All Phase 1 testing was conducted from GM nodes — acceptable for regtest. Proper enforcement and testing requires a non-GM caller node which is Phase 2 infrastructure. |
| KDD-028 — PoSe decay and disk persistence | In-memory only in Phase 1. Restarts are controlled and deliberate in regtest. Decay logic and persistence require Phase 2's longer-running live environment. |
| ODC-017 — UTXO lock contention | PTXSESS builder and staking thread contend on the GM wallet. Resolved architecturally by the dedicated caller node (BUG-010) in Phase 2. |
Hash commit-reveal replaced by threshold BLS12-381. 11-node Docker testnet. Real P2P networking and fault injection for the first time.
Hash commit-reveal replaced by threshold BLS via supranational/blst (formally verified). For any given round seed and quorum public key, exactly one valid output exists. The last-revealer advantage is eliminated entirely — no individual node can see what the output will be before signing.
Distributed key generation with 11 nodes establishes the quorum signing key. Phase 2 uses a trusted-dealer setup — full Pedersen DKG comes in Phase 3.
Toxiproxy fault injection introduces real latency, packet loss, and connection drops between nodes. Phase 1 fault injection was RPC-flag simulation. Phase 2 is real network misbehaviour.
Round status, committed lists, and withheld lists broadcast to peer nodes so any node in the cluster can answer status queries — not just the initiating node.
PoSe scores persist across restarts. Score decay added: -1 per honest round participated. Misbehaving nodes can recover; attacking nodes accumulate penalties that survive node restarts.
GM nodes are prohibited from calling ptx_roll(). A dedicated non-GM caller node is provisioned. This also resolves the UTXO lock contention (ODC-017) between PTX fee payment and the staking wallet.
Quorum lottery selection validated over 10,000 rounds. Node selection distribution confirmed to match the ticket-weighted probability model.
What Hemis is, how PTX works, the HMS token, the network, and how to get involved. No blockchain expertise required.
This distinction matters. PTX does one thing: it will produce verifiable random numbers. What you build with them is your business.
Produce verifiable, tamper-proof random integers. Return them with a cryptographic proof. Post a permanent on-chain record. That is the entirety of what PTX will do.
PTX will have no concept of game outcomes, winners, losers, wagers, prizes, or payments. A result of [7, 23, 4, 51, 12] is five integers. What those mean is entirely the caller's concern. Application logic, payments, and regulatory compliance are the developer's responsibility.
The difference between PTX and a server-side RNG is what happens after the result is delivered.
A server-side RNG players can't inspect. Rate manipulation is undetectable. Regulators demand internal audit logs. Data miners find inconsistencies and you have a PR crisis with no recourse.
Every result will be cryptographically signed by a decentralised quorum. Manipulation is mathematically impossible after the seed is set. Regulators will get a block explorer link. Players become your quality assurance.
The platform controls the RNG. Players can't confirm results. Tournament outcomes disputed forever. No audit trail, no recourse.
Players, journalists, and regulators will be able to independently reproduce every outcome from the on-chain seed. Your competitive moat will be a block explorer link — not a marketing claim.
UTXO blockchain, Bitcoin-derived, Proof of Stake, 60-second blocks. Every PTX result will be committed here permanently. The public record anyone can inspect.
Live since Feb 2024Peer-to-peer network of collateralised Gamemaster nodes. Threshold BLS signing. No individual node will be able to determine or influence the output alone.
410 nodes liveptx_roll(count, low, high, unique, exclude). One call. Result in seconds. On-chain proof automatic. No smart contracts required.
Opens Phase 3 · Q2 2027Each Gamemaster generates a secret, commits to it with a hash, then reveals it. The beacon is SHA256 of all revealed secrets. Nodes that withhold receives PoSe penalties and lose lottery eligibility.
Limitation: a last-revealer knows other nodes' contributions and could theoretically withhold. The PoSe penalty makes this economically unattractive but doesn't eliminate the mathematical possibility. Threshold BLS (Phase 2) eliminates it entirely.
Threshold BLS12-381 via supranational/blst (formally verified). For any given round seed and quorum public key, exactly one valid output exists. Last-revealer advantage is eliminated entirely — no individual node can see what the final output will be before signing.
Linear emission over 10 years. No halving. ~7.99M in circulation as of May 2026.
Active Gamemaster nodes as of May 2026. Running on the existing chain — PTX will extend their role.
Public airdrop to 951 recipients across 56 countries. No token sale. No VC allocation.
| Category | Tokens | % Supply | Notes |
|---|---|---|---|
| Investors | 200,000 | 0.67% | Distributed at launch |
| Founders | 600,000 | 2.00% | Distributed at launch |
| Airdrop | 800,000 | 2.67% | Community · 951 recipients · 56 countries |
| Dev Fund (Year 1) | 292,000 | 0.97% | 12 monthly instalments · transparent treasury |
| To be minted (10yr) | ~29,200,000 | 93.69% | Linear emission to stakers & Gamemasters · no halving |
What was proposed in July 2023, what PTX delivers in May 2026, and where the two diverge — recorded factually, not as spin.
Hemis is a new layer 1 blockchain platform that will provide platform agnostic tools for the creation of simple and fun games with elements of chance without the need to write complicated and expensive contracts.
— Daniel Ames, Project Co-Founder, Original Hemis Whitepaper, July 2023The original whitepaper described a toolkit for creating and playing games of chance. It proposed NFT game pieces with attributes, game creator royalties, play-to-earn mechanics, and a game publishing platform. The audience was game creators and community investors.
The core architectural proposition — a Layer 1 UTXO chain with collateralised second-layer nodes using deterministic quorum subsets to produce verifiable randomness, delivered via a simple API with no smart contracts — survived intact from 2023 to 2026. Daniel wrote the load-bearing structure. Everything else was layers on top of it.
Takosha Churu, the technical architect, died in June 2023 before the design could be fully specified. Daniel Ames stepped back in 2025. The community DAO elected a new team who inherited the whitepaper, the chain, and 410 nodes — but not the original architects' detailed technical intent. Their first task was to understand what they had. The formal KDD/ODC design process — 28 decisions, 16 open choices — was their output.
Working through design decisions formally revealed that NFTs, royalties, and a game creator toolkit were not required for the core primitive to work. Each was a layer on top. Each layer added complexity and attack surface. Each was removed. This is not a criticism of the 2023 whitepaper — it was written for a community audience, not as a technical specification.
The 2023 whitepaper addressed one market: people who want to build dice games. The 2026 design is application-agnostic — any application requiring a verifiable random number can use PTX. This is a broader and more defensible market position, and more honest about what the technology actually does.
Green = unchanged · Amber = evolved · Strikethrough = dropped · Teal = new addition
| Dimension | 2023 Whitepaper | 2026 PTX Design |
|---|---|---|
| What it is | Games platform | Randomness primitive / infrastructure layer |
| Who it serves | Game creators | Any application needing verifiable randomness |
| Core delivery | Toolkit: dice, cards, NFT pieces | ptx_roll() — one API call |
| Chain foundation | UTXO L1, PoS, 60s blocks | Unchanged |
| Node network | Gamemaster nodes, collateralised | Unchanged — 410 live May 2026 |
| No smart contracts | Core principle | Core principle — unchanged |
| Cryptography | "Proprietary algorithms" — unspecified | Hash commit-reveal (Ph1) → threshold BLS12-381 (Ph2+) |
| Statistical proof | None proposed | NIST SP 800-22 — 15/15 on reference C |
| Anti-grinding | Not specified | Block height anchoring (KDD-003) |
| API contract | RPC API described — no parameters | ptx_roll(count, low, high, unique, exclude) fully specified |
| NFT game pieces | Core feature | Dropped — application-layer concern |
| Game creator royalties | Core value proposition | Dropped — outside PTX scope |
| Play-to-earn | Player earnings model | Dropped — PTX produces randomness, not rewards |
| Slashing | Implied conventional penalties | Explicitly rejected (KDD-023) — PoSe + lottery exclusion only |
| Design process | 9-page non-technical whitepaper | 28 KDDs, 16 ODCs, design doc v3.5, API ref v3.5, tech overview v3.5, Phase 1 implementation plan |
| Build validation | None specified | Phase 0 formal test suite — published pass/fail results |
A Layer 1 UTXO blockchain with a peer-to-peer network of collateralised second-layer nodes uses deterministic quorum subsets to produce verifiable randomness, delivered to any developer via a simple RPC API, with no smart contracts required.
— This sentence describes both the 2023 whitepaper and the 2026 PTX design. Daniel Ames wrote it in 2023. The new team implemented it in 2026.PTX won't accept developer integrations until Phase 3 (Q2 2027). Phase 1 is complete. Phase 2 (testnet) is next. The right move now is Discord.
The primary channel for development updates, technical discussion, and support. Official support channel for the Hemis project.
Hemis node software and codebase. PTX is being built on top of existing hemisd infrastructure.
Development announcements and updates.
API docs and SDK will be available at Phase 3 (Q2 2027). The goal is that anyone who can make an HTTP call can integrate PTX. Join Discord now to follow the design and give feedback on the API before it locks into production.
410 Gamemaster nodes are currently active on the existing Hemis chain. PTX Gamemaster participation will open from Phase 2 onwards. Node operators will earn from the daily lottery reward pool.
Any HMS holder can stake to earn a share of block rewards. HMS currently trades on NonKYC exchange (HMS/USDT and HMS/BTC pairs). The project operates as a community DAO.
Join the Hemis developer community. API docs, SDK, and testnet access coming in Phase 4.