One wallet for every game you ship.
Embedded Solana wallets your players sign in to with Telegram or a browser wallet — no seed phrases. Server-side signing, a high-frequency betting ledger, multi-tenant keys, and a self-serve portal. The whole money layer, behind one SDK.
Telegram-native login.
Players inside a Telegram Mini App sign in automatically — zero taps. On the web, they connect any Solana wallet. One SDK handles both.
Server-side signing.
Every transaction is signed on our backend with AWS KMS envelope encryption. No device signing on the hot path, no key material in the browser.
Player UX, not crypto UX.
No seed phrases. No gas popups. Players see a balance and a game — the wallet stays invisible until they need it.
One backbone for every game you ship.
From the first sign-in to high-frequency settlement and regulated cash-out — the whole money layer, behind one SDK.
Embedded sign-in
Telegram Mini App auto-login, any Solana browser wallet (SIWS), or email + one-time code. No seed phrases, no extensions — players are in with zero taps.
Server-side signing
Every transaction is signed on our backend with AWS KMS envelope encryption — no device signing, no key material in the browser.
High-frequency ledger
Lock a stake once, then run bet / win / rollback at memory speed and settle the net on-chain. Built for games that move money many times a second.
Multi-tenant by design
One studio, many apps. Per-app publishable + secret keys, isolated test (devnet) and live (mainnet) environments — Stripe-style.
Self-serve portal
Sign up, create an app, get keys, rotate them, watch activity, and request live access — all without us in the loop.
Server-to-server verification
Your backend verifies a player's wallet session with your secret key and gets the canonical identity — then mints its own JWT. Never trust the browser.
Portable identity & profiles
A player's wallet address keys off who they authenticate as — the same across all your games. Each login captures a profile (Telegram username, email) returned with the verified identity for attribution and greetings.
Regulated-entity ready
Flip an app to isolated, custodial, fiat-only and its funds are ring-fenced — own address, no key export, cash-out only via approved rails.
Full wallet lifecycle
Balances, deposits, withdrawals, self-custody export, and signed webhooks — one React provider on the front end, one secret-key SDK on the back.
One SDK away from a wallet in your game.
Spin up an app, get sandbox keys, and drop in the React provider — live in minutes.
Settle a thousand bets, touch the chain twice.
On-chain per action is too slow for real-time games. The ledger locks a stake once, runs bet / win / rollback off-chain at memory speed, and settles the net on-chain at the end.
- Idempotent on a transaction id — a retry never double-debits.
- Wins reference their bet; a rollback for an unseen bet is remembered.
- Funds locked in a session are untouchable by withdraw or export.
- Server-to-server only — the browser can never call win on itself.
// one on-chain lock to start the session
const s = await wallet.ledger.openSession({
userId, gameCode: "momentum", currency: "USDC",
lockAmount: 50_000_000n,
});
// then bet / win / rollback at memory speed
await wallet.ledger.bet({ sessionToken: s.sessionToken,
transactionUuid: "r1", amount: 1_000_000n, round: "1" });
await wallet.ledger.win({ sessionToken: s.sessionToken,
transactionUuid: "r1-w", referenceTransactionUuid: "r1",
amount: 1_800_000n, round: "1", roundClosed: true });
// settle the net back on-chain, once
const { payout } = await wallet.ledger.settleSession(s.sessionToken);Wrap your app in a provider. Get wallets, auth, and signing.
IAMGame Wallet handles wallet creation, session management, and transaction signing. Your game code stays clean — just call hooks.
import {
IAMGameWalletProvider,
useWalletAuth,
useWallet,
useWalletSign,
} from "@iamgame/wallet-sdk"
<IAMGameWalletProvider
publishableKey="pk_live_..."
baseUrl={API_URL}
>
<App />
</IAMGameWalletProvider>
// In any component
const { user } = useWalletAuth()
const w = useWallet()
const { signAction } = useWalletSign()
await signAction({
walletId: w.id,
txBase64: serializedTx,
})Telegram or wallet
- Inside Telegram: auto-login from initData, zero clicks.
- On web: Sign-In With Solana (SIWS) via Phantom, Solflare, or Backpack.
- Session tokens refresh automatically. Players stay signed in.
Server-side signing
- Wallet keys are encrypted with AWS KMS. Never exposed to the client.
- One API call to sign any Solana transaction.
- Idempotency keys prevent double-spends. Rate limiting built in.
Live in five steps.
From zero to wallet-enabled game in under an hour. The SDK handles auth, wallet provisioning, and signing — you focus on your game.
- 1
Get your API keys
Sign in to the developer portal and create an app to get a publishable key and secret key. Keys are scoped per app — one studio can run multiple games.
- 2
Install the SDK
Add the SDK package to your frontend project.
bashnpm install @iamgame/wallet-sdk - 3
Wrap your app
Add the provider at the root of your React tree. Pass your publishable key and the API base URL.
TSimport { IAMGameWalletProvider } from "@iamgame/wallet-sdk" const API = "https://api-wallet.iamgame.com/v1" export default function App({ children }) { return ( <IAMGameWalletProvider publishableKey="pk_live_..." baseUrl={API} > {children} </IAMGameWalletProvider> ) } - 4
Add login
Drop in the login component. It auto-detects Telegram Mini Apps and shows wallet selection on web.
TSimport { WalletLogin } from "@iamgame/wallet-sdk" function LoginPage() { return ( <WalletLogin onSignIn={() => router.push("/play")} autoTelegram={true} /> ) } - 5
Use wallet hooks in your game
Access auth state, wallet info, balances, and signing from any component.
TSimport { useWalletAuth, useWallet, useWalletBalance, useWalletSign, } from "@iamgame/wallet-sdk" function GameScreen() { const { user, status } = useWalletAuth() const wallet = useWallet() const balance = useWalletBalance(wallet?.id) const { signAction } = useWalletSign() const handlePlay = async () => { const { signature } = await signAction({ walletId: wallet.id, txBase64: myGameTransaction, }) // Transaction signed and submitted } return <button onClick={handlePlay}>Play</button> }
That’s the whole integration.
Grab sandbox keys and have a wallet running today.
What generic wallet SDKs can’t do.
Built for games, not DeFi.
Generic wallet providers assume self-custody for everyone. Games need invisible UX and server-side control. That's what IAMGame Wallet does.
Telegram-first distribution.
Telegram Mini Apps are the fastest-growing game distribution channel on Solana. Our SDK auto-detects TMA context and signs players in with zero taps.
Server-side signing. Always.
No device signing on the hot path. Every transaction goes through our backend signer with AWS KMS envelope encryption, returned in a single round trip.
Solana-native.
Not an EVM wallet with Solana bolted on. Built from scratch for Solana's speed and cost profile. Versioned transactions, SPL tokens, priority fees — all handled.
One SDK, full wallet lifecycle.
Auth, provisioning, balance queries, signing, withdrawals, and key export — all from a single React provider. No glue code between three different services.
A money layer, not just a wallet.
Generic SDKs stop at signing. We add a high-frequency ledger — lock once, bet/win/rollback off-chain, settle the net — so real-time games don't wait on the chain.
Multi-tenant and compliance-ready.
Per-app keys, isolated test/live environments, and a flip to make a regulated entity's funds isolated, custodial, and fiat-only — sandbox game to licensed operator.
Ship a wallet this week.
Create an app, grab sandbox keys, and integrate in minutes — no call required.
Common questions.
What is IAMGame Wallet?
An embedded wallet SDK for game studios on Solana. It handles wallet creation, user authentication (Telegram, browser wallets, and email), transaction signing, balance management, and a high-frequency betting ledger — so your game doesn't have to.
How do players sign in?
Three methods, all ending in the same session. Inside a Telegram Mini App, players are signed in automatically — zero clicks. On the web, they connect a Solana wallet (Phantom, Solflare, Backpack) and sign a challenge, or sign in with their email and a 6-digit one-time code — no wallet needed. You enable the methods you want per app.
Where does signing happen?
Always on our backend. Wallet keys are encrypted with AWS KMS and never leave the server. Your game sends the transaction, we sign and return it.
What can a player do with their wallet?
Check balances (SOL and SPL tokens), receive funds, sign game transactions, withdraw to an external address, and export their private key to take full custody.
Can players export their keys?
Yes. Players can export their wallet's private key at any time. Export creates a new wallet and transfers remaining funds to it automatically.
How long does integration take?
Under an hour for a basic setup. Install the SDK, wrap your app in the provider, add the login component, and use hooks for signing. Five steps, all documented above.
What chains do you support?
Solana. Built natively for Solana's speed and transaction model. Versioned transactions, SPL tokens, and priority fees are all supported out of the box.
How are keys protected?
Each wallet key is envelope-encrypted with AWS KMS using a per-tenant Customer Master Key. The plaintext key only exists in memory during signing, never on disk or in logs.
Is there a cost?
Contact us for pricing. We offer free tiers for early-stage games and volume pricing for studios with scale.
How do I get API keys?
Reach out at socials@iamgame.com. We'll set up a studio account and issue your publishable and secret keys within 24 hours.