Building a Secure Crypto Wallet in Telegram with MPC and AA

With over 10 years in Web3 and 50+ launched projects, we bring deep expertise to TMA wallet development. A user sees a Telegram bot, taps "Open Wallet" — and within seconds can send USDT without installing a separate app. This radically shortens onboarding: instead of installing an app, creating a seed phrase, and writing down 12 words — just a TMA inside the chat. But TMA is severely limited: no filesystem access, localStorage is unreliable, iOS WebView cuts cryptographic APIs, and most importantly — storing a seed phrase in browser memory is dangerous. Therefore, wallet architecture in TMA is always a compromise between security and UX. We solve this challenge through MPC and Account Abstraction, backed by over 10 years in Web3 and 50+ launched projects. We specialize in TMA wallet development, combining MPC wallet Telegram expertise with Account Abstraction.

What problem we solve

The user wants to manage crypto assets directly in Telegram but is not ready to trust anyone with a seed phrase. TMA provides no secure storage — localStorage, sessionStorage, and IndexedDB are cleared by Telegram or read by malicious JS. Solution: server-side storage with client-side encryption. The user's PIN is transformed into a 256-bit AES-GCM key via PBKDF2 with 600,000 iterations, the server only receives an encrypted blob. Decryption without the PIN is impossible — it never leaves the TMA.

The second problem is gasless transactions. The user doesn't want to worry about gas. We use Account Abstraction (ERC-4337, EIP-4337) with a paymaster that pays gas in project tokens or fiat. This improves UX and reduces the cost of first transactions by 30-40%, saving up to $0.5 per operation. At 10,000 transactions per month, savings reach $5000. Typical MVP development starts at $15,000, and a full multi-chain product with AA ranges from $50,000 to $80,000.

TON vs EVM: which blockchain to choose?

Blockchain choice determines audience and functionality. TON (The Open Network) has native integration with Telegram: TON Space is already built-in, TonConnect is the standard for dApps. TonConnect is the standard for Telegram Mini App wallets. The SDKs @ton/ton and @tonconnect/sdk provide ready-made primitives for transactions. The TON audience is already in Telegram, and the DeFi ecosystem is growing fast. Suitable if your project targets Telegram-native activity.

EVM (Ethereum, Polygon, Arbitrum) offers a huge DeFi ecosystem but lacks native integration. We use Web3Auth for Telegram Mini App key management or ZeroDev AA for Telegram wallet account abstraction. The user can interact with any EVM contract. Suitable for DeFi applications with a broad audience.

A combined approach (TON + EVM) extends coverage but is technically more complex. We recommend it for multi-chain projects.

Key difference: an MPC wallet is deployed 2x faster than a full AA, but AA offers gasless and batched transactions. In 80% of cases we choose a hybrid: MPC for the critical key, AA for operations. According to our statistics, this approach increases user retention by 35%.

Architecture: three approaches

Custodial with MPC backend — the user does not directly manage keys: the platform stores shards on multiple servers (MPC). This provides fast recovery and simple UX, but carries custodial risk and requires licensing. Identification via telegram_user_id leads to a deterministic address. Implementation: Web3Auth MPC Core Kit or Fireblocks API.

Embedded wallet with Account Abstraction — generate a key on the device, but the contract wallet supports multiple owners and social recovery. The key is in TMA memory — on app close you either store it server-side (custodial element) or derive it again. ZeroDev SDK simplifies creating a Kernel Account with paymaster.

TonConnect for TON — opens TON Space or Tonkeeper via deep link. For the application's own wallet, we use TON SDK with server-side keys.

Why MPC and Account Abstraction are the foundation of TMA wallet security

The combination of MPC and AA solves TMA's key problems: lack of secure storage and high fees. MPC distributes the key among servers — no single server knows the full key. AA allows transactions without native gas using a paymaster. This increases conversion by 40% compared to wallets that require buying gas. In our projects, we have achieved 99.9% uptime for MPC servers, ensuring 24/7 availability of funds.

How we do it: tech stack and code examples

TMA initialization and signature verification

import WebApp from '@twa-dev/sdk'; WebApp.ready(); WebApp.expand(); const user = WebApp.initDataUnsafe.user; // initData — string for Telegram signature verification 

Verification of initData on the server is mandatory for any wallet operation, as described in Telegram WebApp documentation:

import crypto from 'crypto'; function verifyTelegramData(initData: string, botToken: string): boolean { const params = new URLSearchParams(initData); const hash = params.get('hash'); params.delete('hash'); const dataCheckString = Array.from(params.entries()) .sort(([a], [b]) => a.localeCompare(b)) .map(([k, v]) => `${k}=${v}`) .join('\n'); const secretKey = crypto .createHmac('sha256', 'WebAppData') .update(botToken) .digest(); const expectedHash = crypto .createHmac('sha256', secretKey) .update(dataCheckString) .digest('hex'); return hash === expectedHash; } 

Telegram signs initData with the bot token. Forging it without the token is impossible. Every request to the wallet API must include initData and pass this check.

Account Abstraction with ZeroDev

import { createKernelAccount, createKernelAccountClient } from '@zerodev/sdk'; import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator'; const signer = privateKeyToAccount( deriveKeyFromTelegram(WebApp.initDataUnsafe.user.id) ); const ecdsaValidator = await signerToEcdsaValidator(publicClient, { signer, kernelVersion: KERNEL_V3_1, }); const account = await createKernelAccount(publicClient, { plugins: { sudo: ecdsaValidator }, kernelVersion: KERNEL_V3_1, }); const kernelClient = createKernelAccountClient({ account, paymaster: { getPaymasterData: async (userOp) => { // Returns signed paymasterData from our server }, }, }); 

Gasless transactions via paymaster: the user spends no ETH, gas is paid by the project.

TonConnect for TON

import TonConnect from '@tonconnect/sdk'; const connector = new TonConnect({}); const walletsList = await connector.getWallets(); await connector.connect({ universalLink: wallet.universalLink, bridgeUrl: wallet.bridgeUrl, }); await connector.sendTransaction({ validUntil: Math.floor(Date.now() / 1000) + 300, messages: [{ address: recipientAddress, amount: toNano('0.5').toString(), payload: cell.toBoc().toString('base64'), }], }); 

Secure key storage: PIN-based encryption

async function encryptShare(share: Uint8Array, pin: string): Promise<string> { const pinKey = await crypto.subtle.importKey( 'raw', new TextEncoder().encode(pin), 'PBKDF2', false, ['deriveKey'] ); const salt = crypto.getRandomValues(new Uint8Array(16)); const aesKey = await crypto.subtle.deriveKey( { name: 'PBKDF2', salt, iterations: 600_000, hash: 'SHA-256' }, pinKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt'] ); const iv = crypto.getRandomValues(new Uint8Array(12)); const encrypted = await crypto.subtle.encrypt( { name: 'AES-GCM', iv }, aesKey, share ); return JSON.stringify({ salt: btoa(String.fromCharCode(...salt)), iv: btoa(String.fromCharCode(...iv)), data: btoa(String.fromCharCode(...new Uint8Array(encrypted))), }); } 

The server stores the encrypted blob; decryption without the PIN is impossible. The PIN is never sent to the server.

Tech stack table:

Process of work

1. Analytics and architecture: define requirements (custodial/AA, TON/EVM, gasless), draw flow diagram. At this stage, we lay the foundation for 30-40% gas cost savings via AA.
2. UI design: adapt to Telegram UI (CSS variables, @telegram-apps/telegram-ui), design send/receive/history screens.
3. Backend development: Node.js + Fastify, PostgreSQL for metadata, Redis for sessions. Integration with MPC/AA SDKs.
4. Smart contracts: write and test contracts (Hardhat/Foundry) for AA vault or multisignature.
5. Integration and testing: unit tests, integration via Tenderly Fork, fuzzing (Echidna).
6. Conduct a TMA security audit before release — we work with leading auditors.
7. Deployment and monitoring: deploy to production, set up alerts, rate limiting.

What's included in the work

• Source code for private frontend and backend (NDA).
• Deployed infrastructure (Web3 RPC, paymaster, MPC nodes).
• Full API and architecture documentation.
• Training for the client's team (2-3 days).
• Warranty support for 1 month after release.

Timeline estimates

Cost is calculated individually, depending on the complexity of integrations and security requirements. Request a project evaluation — we will analyze your task and propose the optimal solution. Our experience: over 10 years in Web3, 50+ launched projects (wallets, DeFi, NFT). Contact us to discuss details.

MPC architecture reduces time to MVP by 2-3 times compared to building AA from scratch, and gasless transactions increase user conversion by 40%. Get a consultation — write to us, and we'll prepare a proposal within 2 days.

A crypto wallet in Telegram bot allows instant transactions. We use Web3Auth for Telegram Mini App key management and ZeroDev AA for Telegram wallet account abstraction. TonConnect is the standard for Telegram Mini App wallets. Our team has over 10 years of experience in Web3 and has successfully delivered 50+ projects.