The financial infrastructure behind a Web3 game — embedded wallets, a real order book, an NFT marketplace, treasury and risk controls. Your players earn, trade and cash out without ever seeing a wallet. You keep the treasury, the analytics and the fees.
20 minutes, no slides — we walk your economy through the running stack.
None of them is "ship a great game". That is the gap this exists to close.
One SDK. Your players get a wallet they never see, a real order book, and cash-out — inside your game, under your brand. You get the treasury, the fee share and the analytics. The financial infrastructure is ours to run and yours to profit from.
Your game talks to one SDK. Everything below it — matching, custody, settlement, chain — is infrastructure you never have to operate.
The entire loop below runs on this page's infrastructure right now. You can play it.
Signs in with the account they already have. A wallet is provisioned in under a second.
Gameplay rewards credit your token as a real ledger entry, not a database counter.
Items mint as tradable assets with rarity, owned by the player.
Sells to another player on a real order book, with your royalty enforced at settlement.
Withdraws to their own wallet — policy-gated, and only if you allow it.
A real game on the real stack — every drop and trade is a ledger transaction you can audit.
Retention mechanics — daily spins, prediction games, staking, leaderboards — shipped as white-label templates on the rails. Every balance, prize pool and payout below is the kind of number the double-entry ledger already settles today.
Concept UI from the engagement-layer roadmap. The rails underneath — balances, prize pools, payouts, rankings — are the live ledger and matching engine you can test on this site today.
Every surface — the exchange terminal, the studio console, the player wallet — is themed from design tokens. Your brand, your domain, your palette. Nothing here says GameFi Rails unless you want it to.
Your choice follows you into the exchange, the console and the game — it is the same token set driving all of them.
Adopt the whole stack or just the parts you're missing — each module works standalone.
A real order book in Rust — limit, market, IOC, FOK, post-only — with price-time priority, deterministic replay, and 97-nanosecond order placement. Kill it mid-session and it restarts to a bit-identical book.
Wallets created from your existing accounts. Keys under envelope encryption with hot/warm/cold segregation.
List, buy and sell game items with creator royalties enforced at settlement, not by convention.
Your game token with supply, distribution, holders and velocity tracked from the ledger itself.
Studio-owned balances, fee revenue and policy-gated withdrawals with approval thresholds.
Wash trading, velocity abuse and price manipulation detected live on the event stream — and circuit breakers that actually fire. A simulated wash-trading ring halts its pair in seconds, automatically.
Emissions versus sinks, holder concentration, selling pressure. Health, not just volume.
TypeScript and Unity today, with the same typed contract and retry semantics on both.
Not adjectives. These are properties you can test yourself against this deployment.
The matching engine restarts to a bit-identical order book from its snapshot and event log. No lost orders, no double fills — matching is a pure function of the log.
verify: pnpm chaosEvery movement of value posts double-entry rows summing to zero per asset, and a job asserts it continuously. A shortfall parks in suspense and halts the pair rather than overdrafting a player.
verify: pnpm reconcileTrades settle through an inbox keyed to the engine's sequence, in the same transaction as the ledger write. Redelivery is a no-op, never a double-spend.
verify: kill settlement mid-stream, replayCriterion benchmarks on the real engine, and a load test that drives real orders through the whole pipeline — HTTP, queue, engine, settlement, ledger.
verify: pnpm rust:bench · node scripts/load.mjscriterion on the real engine · end-to-end latency is bounded by your database round-trip, not the matcher
Players sign in with the account they already have. The wallet, the exchange and the marketplace are invisible infrastructure behind your game's own UI.
import { GameFiClient } from '@gamefi-rails/sdk-js'; const gamefi = new GameFiClient({ baseUrl, apiKey }); // A player, identified however your game already does it const player = await gamefi.createPlayer('steam:12345'); // Reward gameplay — a real ledger credit await gamefi.reward(player.playerId, 'boss-slain'); // Loot becomes a tradable asset await gamefi.mintNft(player.playerId, 'swords', 'Ember Fang'); // And the player cashes out on a real order book await gamefi.placeOrder({ playerId, side: 'Sell', price: '2.40', qty: '10' });
No seed phrases. No gas. No leaving the game.
Every trade splits fees to your studio automatically.
The financial core is running today. Everything after it compounds on the same ledger, the same tenancy model and the same SDK surface — no rewrites between phases.
Platform fee on transactions, shared back with you. Indicative — final terms depend on volume, liquidity contribution and jurisdiction.
Not a mockup and not a video. Slay a dragon, earn tokens, loot an NFT, sell it to another player, and cash out on the live order book — against the same infrastructure a studio would run in production.