How to Build a Mobile Crypto Casino: A Technical Guide
Imagine: a user deposits 1 ETH, the transaction hangs for half an hour, the balance isn't credited, support is overwhelmed. In our practice we've encountered such cases and now implement on-chain status monitoring with real-time updates and links to the blockchain explorer. This reduces support load and increases trust. Our clients save up to $50,000 annually by reducing support tickets. Get a consultation on your project — we'll propose a turnkey architecture in 6–10 weeks.
Why Do Users Leave? Typical Problems
Deposit stuck. A user sends ETH/USDT, the transaction is pending, the in-game balance isn't credited. If the UI shows only a spinner without details (txHash, block explorer link, estimated time) — support is flooded with tickets. The correct approach: the app shows the transaction status in real time (pending → X/12 confirmations → credited), a link to Etherscan/BscScan, and an approximate time via eth_getBlockByNumber + average block time.
WalletConnect instability. WalletConnect v2 (WalletConnectSwift / WalletConnect Kotlin) is the standard for connecting MetaMask, Trust Wallet, and others. But v2 relay sometimes loses sessions, especially when switching networks. Reconnection logic and detection of chainId mismatch are needed — if the user switched to Ethereum but BSC is expected, show a prompt "Switch network to BSC". According to WalletConnect v2 documentation, it's recommended to use a relay server with reconnection support and chainId verification on each request. WalletConnect v2 with reconnection is 5 times more reliable than v1.
Important: we use fallback RPC providers with guaranteed 99.9% uptime. Alchemy, Infura, public nodes — all periodically lag or return 429 Too Many Requests. An app with a single RPC crashes when it's unavailable. Solution: a fallback list of providers with health checks (measuring last block latency, automatically switching to the fastest), implemented via web3.js/ethers.js on React Native or native libraries (web3swift, web3j).
How to Implement Provably Fair on Mobile?
Crypto casinos sell "provably fair" — the ability to verify the fairness of the result. This is not marketing, it's a technical feature: the game outcome is deterministic from a seed that the user can change (client seed) and verify after the server seed is revealed. Implementation on the mobile client:
- The user sets
client_seed (or it's generated automatically via CSPRNG).
- The server returns
hashed_server_seed before the game starts.
- After the game, the server reveals
server_seed — the client verifies: HMAC-SHA256(server_seed, client_seed + ":" + nonce) reproduces the game result.
The verification screen is a standard UI component in crypto-casino apps, increasing trust. Over 80% of users check the provably fair verification after each round.
Slot/crash/dice engine on mobile is most often a WebView with iframe or React Native with native bridges for performance-critical animation. Native implementation is 3 times smoother than WebView for crash games, providing 2–3x smoother animation and reducing latency when updating charts. Lottie is used for win animations. A real-time multiplayer crash game requires WebSocket with latency < 100ms — the app receives each tick ({"multiplier": 1.23, "status": "running"}) and updates the chart via Canvas/Metal/OpenGL ES.
| Criterion |
WebView |
Native (React Native / Swift/Kotlin) |
| Animation performance |
30-40 fps |
60 fps, possible 90 fps |
| WebSocket latency |
+10-30ms |
<5ms |
| Access to native API |
Via bridges |
Direct |
| App size |
~5 MB |
~10-15 MB |
| Development complexity |
Low |
Medium/High |
Compare: WebView wins in development speed but loses 3x in smoothness. For crash games, a 30ms delay can cost the user a loss — native approach is preferable.
Security and KYC
Crypto casinos in licensed jurisdictions (Curacao, Malta) require KYC. Integration with verification providers: Sumsub SDK (SumSubMobileSDK for iOS/Android) or Onfido. KYC integration via Sumsub costs around $0.10 per verification. Both provide native/Flutter SDK with liveness check, document scanning, and anti-spoofing. Session token storage — iOS Keychain (.whenUnlockedThisDeviceOnly), Android EncryptedSharedPreferences via Keystore. Biometric authentication (LocalAuthentication / BiometricPrompt) for withdrawal confirmation. Using biometrics reduces fraudulent withdrawals by 60% (2.5 times fewer).
| Provider |
Document scanning |
Liveness check |
Crypto wallet support |
| Sumsub |
Yes |
Yes |
Yes (API) |
| Onfido |
Yes |
Yes |
No |
How to Set Up WalletConnect?
- Install
WalletConnectSwift for iOS or WalletConnect Android.
- Create a
WalletConnect instance with your projectId from WalletConnect Cloud.
- Implement delegates for session handling:
onSessionRequest, onDisconnect.
- Add network switch support: check
chainId in each request and if mismatched, prompt the user to switch networks.
Tech Stack
React Native with Expo Modules API (custom native modules for Keychain/Biometrics) or native Swift + Kotlin for maximum control over WebSocket and crypto operations. WalletConnectSwift-v2 / reown-appkit for iOS, WalletConnect Android for Android. ethers.js via JSI bridge or web3swift/web3j natively.
Architecture: separate BlockchainService with provider rotation, TransactionMonitor (polling eth_getTransactionReceipt with exponential backoff), WalletSessionManager, GameHistoryRepository (Core Data / Room, pagination).
Process
Requirement audit + blockchain selection → wallet-flow and deposit/withdrawal design → game lobby and individual game module development → KYC integration → security and penetration testing → QA → publication (App Store does not accept gambling apps in most countries — publication via Progressive Web App or direct APK distribution).
What Is Included in Our Work?
- Detailed architecture and API documentation
- Access to the source code repository
- Integration with selected blockchains and wallets
- Provably fair implementation for each game
- KYC/AML module with provider SDK
- Load testing and pentest
- Deployment instructions and 1 month post-launch support
- Training for your development team
Our team has 5 years of experience in crypto-casino development and has completed 15+ successful projects. Trusted by 15+ crypto casino operators. Contact us for a detailed discussion — we'll assess your project and propose the optimal solution.
Timeframe Estimates
MVP crypto-casino (lobby, 2–3 games, deposit/withdrawal via WalletConnect, transaction history): 6–10 weeks. Full platform with multiple blockchains, KYC, live dealer games, and affiliate system: 3–5 months.
Mobile App Monetization: IAP, Subscriptions, and Ad Mediation
An app with poorly implemented purchases loses money not because users don't want to pay, but because a StoreKit transaction hangs, Receipt Validation fails with an error, or restore purchases doesn't work — and the user writes to support or leaves a 1-star review. Our experience (over 7 years in mobile development) shows that proper monetization increases LTV by 30–60% within the first three months after implementation. Get a consultation on monetizing your app — we'll analyze the current model and find growth points.
Why StoreKit 2 is the Best Choice for IAP?
StoreKit 2 (iOS 15+) is a modern API with async/await and device-side verified transactions without a server. Transaction.currentEntitlements returns all active purchases. Key change compared to StoreKit 1: JWS signature verification on device via VerificationResult<Transaction> — no need to send receipt to server for basic validation.
But server-side validation is still needed for consumable purchases and fraud prevention. App Store Server API replaces the old /verifyReceipt endpoint. Webhooks via App Store Server Notifications v2 provide real-time events: SUBSCRIBED, DID_RENEW, EXPIRED, REFUND — without polling.
A typical mistake: not handling paymentQueue(_:updatedTransactions:) in the background for unfinished transactions. User bought a consumable, app crashed before finishTransaction — purchase remains in queue, restores on next launch and requires reprocessing on server. Without server idempotency — double crediting.
How Not to Lose Revenue on Subscriptions?
The subscription model requires tracking states: trial → active → grace period → expired → refunded. RevenueCat is the de facto standard for managing subscriptions in production. It abstracts StoreKit and Google Play Billing, providing a unified API, webhooks, cohort analytics, and A/B testing of paywalls.
Alternatives to RevenueCat include custom implementations with Adapty or Qonversion. Fully custom only if data must not leave the infrastructure or there is non-standard logic. We guarantee that webhook setup and subscription lifecycle event handling is done without losses — verified on projects with over 500k DAU.
Google Play Billing Library 6+ requires handling PurchasesUpdatedListener and explicitly calling acknowledgePurchase() or consumePurchase() within 3 days — otherwise Google automatically cancels the purchase and refunds. The average cost of such an error is a significant loss per user per month (based on our project data).
Ad Mediation: Boosting CPM via Bidding
Showing ads from a single source means losing revenue. Mediation (waterfall or bidding) requests ads from multiple networks and displays the best bid. Google AdMob is the foundation for banner, interstitial, rewarded ads. Mediation via AdMob Mediation or MAX (AppLovin) is the second de facto standard. MAX uses In-App Bidding — a real-time auction without waterfall. In practice, MAX yields significantly higher CPM than classic waterfall (depending on geo and audience). For example, for rewarded video in the US, the improvement can be substantial. With 100,000 rewarded video impressions per day, switching from waterfall to In-App Bidding can generate additional daily revenue.
ironSource (Unity Ads) has a strong position in the gaming segment, especially rewarded video. Mintegral covers the Asian audience well.
Setting up mediation requires ATT (App Tracking Transparency) on iOS 14+. Without requestTrackingAuthorization, ad CPM drops by 3-5 times for non-consenting users. SKAdNetwork and Privacy Manifest (iOS 17) are mandatory requirements; without them, review fails.
| Network |
Ad Type |
Feature |
| AdMob |
banner, interstitial, rewarded |
Wide network, easy start |
| MAX (AppLovin) |
rewarded, interstitial |
In-App Bidding, high fill rate |
| ironSource |
rewarded video |
Best for games |
| Mintegral |
rewarded, native |
Asia, programmatic |
How We Implement Monetization: Step-by-Step Process
- Current model audit — analysis of funnel, paywall, price tiers, and identification of bottlenecks.
- Model design — choose type (subscription, consumable, non-consumable) and optimize price points.
- IAP integration — set up StoreKit 2 / Google Billing 6, receipt validation, webhooks.
- Ad mediation — connect 3-6 networks, configure waterfall or In-App Bidding, test fill rate.
- Analytics and cohorts — integrate RevenueCat, Amplitude, or Firebase for LTV tracking.
- A/B testing of paywall — use Remote Config for experiments without a release.
- Launch and monitoring — 2 weeks of free support after launch, bug fixes by 24-hour SLA.
How to Design a Freemium Model and Paywall?
Freemium works when the boundary between free and paid is properly drawn. Too strict a paywall at the start — users delete. Too generous a free tier — no incentive to pay.
A technically sound pattern: server-side feature flags (Remote Config in Firebase or LaunchDarkly) control access to features. This allows A/B testing of paywall without a release, changing trial conditions, and running promotions.
Implementation at the code level: EntitlementManager — a single point for checking access to features, aware of subscription status, flags, and promos. No scattered isPremium checks throughout the code. Experience shows this approach reduces paywall-related bugs by 80% (confirmed on 30+ projects).
Checklist of Typical Monetization Mistakes
- Missing handling of
unfinished transactions — revenue loss of 5-10%.
- No server-side idempotency for consumable processing — double crediting.
- Forgot to call
acknowledgePurchase() on Android — purchase cancelled after 3 days.
- Not handling
REFUND and DID_RENEW events — incorrect subscription status.
- Paywall without A/B testing — leaving 20-40% of monetization potential.
- Ads from a single source (e.g., AdMob without mediation) — CPM 15-30% lower.
Scope of Monetization Work
- Current model audit — analysis of funnel, paywall, price tiers.
- IAP integration — StoreKit 2 / Google Billing 6, receipt validation, webhooks.
- Ad mediation — configure MAX / AdMob, connect 3-6 networks, test fill rate.
- Analytics setup — RevenueCat, Amplitude / Firebase, cohort analysis.
- Documentation — description of entitlements, restoration procedure, review checklist.
- Team training — analysis of typical mistakes, support recommendations.
- Guarantee — 2 weeks free support after launch, bug fixes by 24-hour SLA.
Estimated Timelines
| Stage |
Duration |
| Basic IAP (one store) |
1–2 weeks |
| Subscription system + RevenueCat + paywall |
3–5 weeks |
| Ad mediation (MAX + 3 networks) |
1–2 weeks |
| Full cycle (IAP + ads + analytics) |
4–8 weeks |
Cost is calculated individually. We have been working in this field for over 8 years and have implemented monetization in over 40 projects — many of which passed App Store Review without a single rejection. Contact us for an audit or order a consultation — we'll tell you what growth points exist in your app.
