Home Blog tech stack to build crypto wallet

Tech Stack to Build a Crypto Wallet: Key Custody to Frontend

Pick the key model first: custodial, non-custodial, MPC or a smart-contract account. Then choose the wallet SDK, key storage, app and backend languages, dApp connection standards and chain access. Use an embedded SDK for speed, an HSM or KMS for custodial signing, and an RPC provider with an indexer for chain data.

Last updated:

Nov 05, 2026

12 mins read

Listen to this article Tap play to start

Key Takeaways

Key model first. It sets who holds funds and how users recover a lost device. Every other layer follows from it.
SDK. Embedded SDKs such as Privy and MetaMask Embedded Wallets give fast sign-up. Build your own for custom key logic or a self-hosted signer.
Key storage. Mobile wallets encrypt the seed with an enclave or Keystore key. Custodial wallets sign in an HSM or cloud KMS. MPC removes the single full key.
Gas. ERC-4337 paymasters sponsor new users. EIP-7702 extends smart-account features to existing accounts.
dApps. Build EIP-1193, EIP-6963 and WalletConnect from day one.
Chains. One adapter per chain family, an RPC provider with a fallback endpoint and an indexer for history.
Build path. White-label for speed, custom when key handling is your product, hybrid to keep the vendor shell and own the key layer.

The key model is the hardest pick to reverse. It decides who loses funds when something breaks and how a user recovers a lost device. Choose it first, then build the rest of the tech stack for crypto wallet development around it.

The Troniex crypto wallet development company team works through these layers with founders before the first line of code. Troniex brings 4+ years in blockchain and AI to that review.

What a Crypto Wallet Tech Stack Covers

A wallet stack runs in tiers. Chain access sits at the bottom, key management in the middle and the app on top. Security and recovery cut across all three.

Crypto wallet stack tiers, with chain access at the bottom, key management in the middle and the app on top.

Not Sure Which Key Model Fits Your Product?

Bring your target chains and custody plan. Our team reviews the stack with you before development starts.

Talk to Our Experts

Custodial, non-custodial, MPC or Smart-contract Account: Choose the Key Model

Pick custodial when you run the balances. Pick non-custodial when users hold their own keys. Pick MPC or a smart-contract account when you want user control with a recovery path.

Model	Who holds the key	Recovery	Audit scope	Fits when
Custodial	Your servers, in an HSM or cloud KMS	Account reset through your support flow	Key storage, signing API, access controls and operations	You run balances, as in an exchange or payment product
Non-custodial	The user, on their device	Seed phrase or passkey backup	App code and key generation	Users want full control and you never hold their funds
MPC	Key shares split across the device and your servers	Share recovery, with optional social recovery	Share protocol, signing service, recovery flow and share storage	No single machine holds the full key
Smart-contract account	A contract, with keys or passkeys as signers	Contract rules, such as guardians	Contract code, bundler and paymaster setup	You need gas sponsorship, spend limits or batched actions

The full custody decision sits in our non-custodial wallet development company guide.

Four crypto wallet key models compared by key holder, recovery method and best fit.

Pick a wallet SDK that creates keys on the user's device, supports social or passkey login and exports the key on request. Check chain coverage, recovery method, pricing per active wallet and whether you self-host later.

To build a non-custodial wallet SDK flow, let the SDK own key creation and login, and let your app own everything after sign-up.

Embedded SDK or build your own

Use an embedded SDK when sign-up speed matters more than owning the key flow. Build your own when you need custom key logic or a self-hosted signer. Two embedded options show what to check:

Privy. Its wallet docs describe non-custodial user wallets across hundreds of blockchains, including Ethereum and Solana. Users sign in with email, SMS, passkey or social accounts. Users export their private key, and a DENY policy switches export off. Privy also offers wallets that your own servers control. Those are not user-held, so label them custodial in your own model.
MetaMask Embedded Wallets (formerly Web3Auth). The docs describe wallet infrastructure with social, email and SMS login, and state that users keep full control of their non-custodial wallets. It provides a key provider for a custom wallet.

Account abstraction for gas sponsorship

Use ERC-4337 when new users hold no gas tokens. The standard adds account abstraction without consensus-layer changes. Users submit UserOperations to a separate mempool, and bundlers package them into transactions. A paymaster is a helper contract that agrees to pay for the transaction in place of the sender, so your app covers fees for new users.

ERC-4337 flow from signed UserOperation to bundler, with a paymaster paying gas.

EIP-7702 (live since the Pectra upgrade in May 2025) lets an existing account delegate to smart-contract code. Existing users keep their address and gain batching and sponsorship. Pick 7702 for existing accounts and ERC-4337 accounts for new ones.

Key Management: HSM, KMS and Device Storage

Store private keys on-device behind the platform keystore, or server-side with an HSM or cloud KMS. Add MPC or threshold signing when no single machine is allowed to hold the key.

On-device storage and curves

Apple's Secure Enclave holds only P-256 keys. It does not generate secp256k1 or Ed25519 keys, the curves most chains use. So keep a key-encryption key in the Secure Enclave (iOS) or Keystore with StrongBox (Android), encrypt the seed with it and decrypt in memory only to sign. Gate decryption behind biometrics.

Four steps a mobile wallet follows to store the seed encrypted and decrypt it only to sign.

HSM and cloud KMS for custodial wallets

Use a cloud KMS or HSM for the hot-wallet signing key of a custodial product. AWS KMS supports the secp256k1 curve for cryptocurrency use and Ed25519 for signing and verification only. Its docs say the private key of an elliptic curve key pair never leaves AWS KMS unencrypted.

Pick the chain first, then check that the KMS or HSM supports its signing curve.

MPC and threshold signing

Pick MPC when custody must survive the loss or compromise of any one server or device. The key exists only as shares, so no machine holds all of it. Depth on share protocols and recovery sits in our MPC wallet development guide.

Compare Your Plan with How We Build Wallets

Share your architecture and get feedback from engineers who have shipped custodial, non-custodial and MPC wallets.

Talk to Our Experts

Choosing Languages for App and Backend

Native app: Kotlin and Swift. Cross-platform app: React Native and Flutter for one codebase. Backend: Node.js or Go to talk to blockchain nodes. Rust: where the chain demands it, as on Solana, or for signing code that must be fast and memory-safe.

Build steps for the app sit in our guide to build a crypto wallet app.

Backend language by job

Pick Node.js when the team shares TypeScript with the app and the work is mostly calls to nodes and APIs. Pick Go for indexers and services that hold many concurrent connections. Reach for Rust on Solana programs or in signing code that must be fast and memory-safe.

Mobile and Desktop Frontend

Go native when you need platform keystore access and biometric signing. Go cross-platform with React Native or Flutter when you ship iOS and Android together on a smaller team. Browser extensions and desktop apps need a separate web stack and a stricter origin model.

Browser extension wallets

Chrome's Manifest V3 replaces background pages with service workers that run only when needed, and an extension executes only JavaScript included in its package.

Service workers stop when idle, so keep no decrypted key in memory between requests. Show the requesting site's origin on every approval prompt. Give each site a request channel.

Connecting to dApps

Wallet connecting to a dApp through EIP-1193, EIP-6963 and WalletConnect.

A non-custodial wallet needs a way to talk to dApps. Build to three standards:

EIP-1193. The JavaScript provider API that dApps call.
EIP-6963. Lets a browser extension announce itself, so several wallets coexist on one page.
WalletConnect. Pairs a mobile or desktop wallet with a dApp running in another browser or device.

Pick these on day one. Retrofitting a provider API after launch breaks every dApp integration.

Multi-chain Infrastructure: RPC and Indexers

Use one adapter per chain family, so adding a chain means adding an adapter. Read through an RPC provider with a fallback endpoint. Add an indexer for balances and history, because raw node calls are too slow for a wallet home screen.

Holding several currencies in one app adds balance and fee logic on top. Our multi-currency wallet development guide covers that layer.

Multi-chain wallet infrastructure with EVM and Solana adapters, an RPC provider with a fallback and an indexer.

Own node or RPC provider

Start with an RPC provider and a fallback endpoint. Run your own node when provider rate limits or data-privacy needs justify the upkeep.

EVM and Solana adapters

Build the EVM adapter once and reuse it for each EVM chain. Build a separate Solana adapter, because transaction format, signing and fees differ.

Derivation paths. BIP-44 defines the path as m / purpose' / coin_type' / account' / change / address_index. EVM wallets follow it directly. Check each non-EVM chain's own derivation scheme before you reuse the path.
Coin types. SLIP-44 lists coin type 60 for Ethereum and 501 for Solana.

Add a Bitcoin adapter on request.

Security Stack and Recovery

Security work runs from the first commit to the signing API after launch. Our crypto wallet security best practices guide covers the user-facing side.

Before release

Run dependency scanning and static analysis to catch obvious issues. Add third-party code review to spot logic flaws.

All Troniex builds get 100% QA with code audits and stress testing.

Recovery paths: seed phrase and MPC

A seed phrase lets users recover if they lose the device. If they lose the phrase and the device, the funds are gone.

MPC share recovery, with optional social recovery, replaces the phrase. If the user cannot reach enough shares, the wallet stays locked.

Recovery paths compared: seed phrase restore and MPC share recovery.

After release: simulation and limits

Simulate each transaction before the user signs, and show the result. Rate-limit the signing API. Add phishing warnings as a second signal.

Build Custom or Start from a White-label Wallet

Choose white-label when the key model and feature set you need already exist in a base. Choose a custom build when key handling is your product. A hybrid keeps the vendor's app shell and swaps in your own key layer.

Option	Who owns the code	Key model choices	Lock-in
White-label base	Vendor owns the base. You own your modules	Those the base supports	Vendor roadmap and licence terms
Wallet clone script	Depends on the licence	Fixed by the script	Licence terms and your own upkeep
Custom build	You	Any key model above	Your chosen vendors' APIs only
Hybrid	Vendor owns the shell. You own the key layer	You swap the key layer	The vendor's app shell

Decision tree for choosing white-label, custom or hybrid wallet development.

Our white-label crypto wallet development service covers the buy option. Troniex has delivered 150+ projects.

Quick Picks by Layer

Layer	Default pick	Pick the alternative when
Key model	Non-custodial or MPC	Custodial when you run the balances
Wallet SDK	An embedded SDK such as Privy or MetaMask Embedded Wallets	Build your own for custom key logic or a self-hosted signer
Key storage	Key-encryption key in the secure enclave or Keystore	HSM or cloud KMS for custodial signing. MPC when no machine holds the full key
Gas	The user pays gas	ERC-4337 paymaster to sponsor new users. EIP-7702 for existing accounts
App	React Native or Flutter	Kotlin and Swift for keystore and biometric signing
Backend	Node.js	Go for indexers. Rust for Solana or signing-critical code
dApp connection	EIP-1193, EIP-6963 and WalletConnect	None. Build all three
Chain access	RPC provider with a fallback endpoint, plus an indexer	Your own node for rate-limit or privacy needs
Build path	Hybrid	White-label for speed. Custom when key handling is the product

Ready to Build Your Crypto Wallet?

Send us your requirements and get a scoped plan covering key model, stack and build path.

Start Your Wallet Project

Frequently Asked Questions

Native apps use Kotlin and Swift. A cross-platform app uses React Native or Flutter. Write the backend in Node.js or Go. Add Rust where the chain demands it, as on Solana, or for fast, memory-safe signing code.

Go native for platform keystore access and biometric signing. Go cross-platform when you ship iOS and Android together on a smaller team. Browser extensions and desktop apps need a separate web stack.

Mobile wallets encrypt the seed with a key held in the secure enclave or Keystore. Custodial wallets sign inside an HSM or cloud KMS. Add MPC when no single machine holds the full key.

Check that keys are created on the user's device, that login covers social or passkey, and that users export the key on request. Then compare chain coverage, recovery method, pricing per active wallet and self-hosting options.

Use one adapter per chain family, read through an RPC provider with a fallback endpoint, and add an indexer for balances and history.

Privy covers hundreds of blockchains and supports policies, such as a DENY policy that switches key export off. For treasury wallets, check each vendor's docs for signing policies, approval workflows and audit logs before you commit.

Build non-custodial when users hold their own keys. Build custodial when you run balances, as in an exchange or payment product. Choose MPC or a smart-contract account for user control with a recovery path.

Yes, through a server-side wallet that your agent calls. Privy's docs describe wallets that your own servers control through its API. Those wallets are custodial from the user's side. Cap amounts and allowed contracts before the agent holds real funds.

Use an embedded or connect-wallet SDK for sign-in, then follow the contract and indexing picks in our tech stack to build a DeFi app guide.

Chain count, custody model, audit scope and platforms set the price. Our crypto wallet development cost guide breaks the drivers down.