Skip to content

Crypto Wallet Development

In short

A wallet is a system, not a screen: key management, a smart-account layer, backend services, and mobile UX. We build all of it, non-custodial, embedded, or custody-backed, with production experience from Safe and Telos zkWallet.

$2B+
assets secured
120+
EVM networks deployed
130+
Safes deployed
1M+
developers (Solhint)
Trusted by teams building on-chain

A wallet is where most people meet your product, and where most of them leave. Seed phrases, gas top-ups, and a confusing first transaction are the reasons real users drop off before they ever use what you built. A crypto wallet is a whole system: key management, a smart-account or signing layer, backend services that keep balances and history correct across chains, and a mobile or embedded UI designed for people who are not crypto-native.

Protofire has shipped 250+ blockchain projects since 2016, and wallets are core infrastructure for us. We helped build Safe, the smart-account wallet that pioneered account abstraction on EVM, and as an official Safe partner we have deployed 130+ Safes across 120+ networks, securing $2B+ in assets.

We shipped Telos zkWallet, a full production wallet that bundled smart contracts, relayer services, and indexing into a cross-platform app with native proof generation. Our open-source wallet work is public: chain-specific Safe wallet interfaces, the ethereal-wallet-monorepo smart-account wallet, and on-chain multisigs on Fuel and Polkadot.

We build the wallet you need, non-custodial, smart-account, embedded inside your app as Wallet-as-a-Service, or backed by an MPC custodian, with the backend and mobile UX behind it. Take a white-label wallet you can ship under your own brand, or the specific layer you are missing.

We maintain Solhint, the Solidity linter used by 1M+ developers, so the contracts inside your wallet are held to the standard we set for the ecosystem.

The wallet stack we build and operate, from key to UX

A wallet is every layer between a user's authority and a confirmed transaction. We design, implement, and run each one.

01

Key & signing

Non-custodial signing (seed phrase, passkey, or device key), smart-account signers, or MPC and custodian integration. The user's authority, however it is held.
02

Smart account

ERC-4337 smart accounts for gasless onboarding, session keys, and social recovery, so the wallet can enforce rules a bare key pair cannot.
03

Backend services

Transaction, indexing, config, and notification services that keep balances, history, and pending operations correct across every supported chain.
04

Chain & RPC

Multi-chain node and RPC access, plus the gas and pricing plumbing a wallet needs to broadcast and display transactions reliably.
05

App & UX

The iOS, Android, browser-extension, or embedded interface: connection flows, transaction previews, and recovery, designed for people who are not crypto-native.
01

What wallet development covers

We build non-custodial wallets (browser extension, mobile, and web), smart-account wallets on ERC-4337, embedded and white-label wallets that live inside your product, and wallets backed by an MPC or custodian for institutional key management. The common thread is that we treat a wallet as a product with real infrastructure behind it, key management, backend services, indexing, and UX, rather than a screen bolted onto a contract.

If you already run part of the stack, we build the layer you are missing and integrate the rest. Benefits: one team for contracts, backend, and app · non-custodial, embedded, or custody-backed · the whole wallet or the one layer you need.

02

How an engagement works

1

Scope & Design

A wallet review that maps the flows you need, selects the wallet type (non-custodial, smart-account, embedded, or custody-backed), and agrees the security and key-management model. Deliverable: a scoped architecture and capability plan.
2

Build & Integrate

The wallet contracts and signing layer, the backend services (transaction, indexing, config, notifications), and the app or embedded UI, integrated across your target chains and tested.
3

Launch & Operate

Rollout and handover, with the contracts hardened ahead of any external audit, and an option to keep us on for managed operations once it is live.
03

What teams build wallets for

Onboarding users with email or social login, no seed phrase
A white-label wallet shipped under your own brand
Gasless first transactions so the product works before funding
Institutional treasury wallets with MPC and policy controls
Mobile wallets for iOS and Android
Recovery without a single seed-phrase point of failure
04

Wallets are infrastructure we already run

Protofire is a blockchain development company with 250+ projects shipped across 60+ networks and 95+ protocols since 2016. Our wallet credentials are first-hand, not a service line we added. We helped build Safe, the smart-account wallet that pioneered account abstraction on EVM, and as an official Safe partner with years inside the Safe codebase, we have deployed 130+ Safes across 120+ networks, securing $2B+ in assets.

We shipped Telos zkWallet, a full production wallet with relayer and indexing infrastructure and native proof generation that cut transaction latency by up to 80%. Our open-source wallet work is public: the ethereal-wallet-monorepo smart-account wallet, chain-specific Safe wallet interfaces, and fully on-chain multisigs on Fuel and Polkadot.

We also build the layers a wallet leans on: account abstraction for gasless and recovery UX, wallet privacy through the Kohaku Standard SDK, and the indexing that keeps balances and history correct. And we maintain Solhint, the linter used by 1M+ developers, so the contracts inside your wallet are held to the standard we set for the ecosystem.

“Seed phrases and gas top-ups are where most users quit before they reach the product.”

Open source we’ve shipped

The Protofire repositories behind this page

ethereal-wallet-monorepo

→

A Safe{Wallet} smart-account wallet

Part of 190+ open-source repositories from Protofire

Wallet models we build

ModelWho holds keysRecoveryGas UXBest for
Non-custodial (EOA)UserSeed phraseUser pays gasUsers who want full self-custody
Smart-account (ERC-4337)User, programmableSocial recovery, no seed phraseGasless via paymasterConsumer apps cutting onboarding drop-off
Embedded / Wallet-as-a-ServiceUser, behind a familiar loginProvider-assisted or socialGasless first actionsOnboarding users who are not crypto-native
MPC / custodianSplit across partiesInstitutional key policyConfigurableTreasury and institutional key management

FAQ

What does crypto wallet development involve?
A crypto wallet is a whole system. Building one means designing and implementing several layers together: the key-management or signing layer (a non-custodial key, an ERC-4337 smart account, or an MPC and custodian integration), the backend services that keep balances, transaction history, and pending operations correct across every supported chain, the node and RPC access underneath, and the app or embedded UI that a real user touches. The engineering work is in making those layers behave as one system: a transaction a user signs on a phone has to be constructed correctly, priced, broadcast, indexed, and shown back as confirmed, reliably, across chains. Protofire builds all of it, and we build it from wallet infrastructure we already run in production for Safe and Telos, rather than from a blank page.
What is the difference between a custodial and a non-custodial wallet?
In a non-custodial wallet, the user controls their own keys and therefore their own funds; the wallet provider, including us, never has the ability to move assets. In a custodial wallet, a third party holds the keys and moves funds on the user's behalf. Most Web3 products want non-custodial by default, because it keeps you out of the business of holding user funds and the regulation that comes with it. There is a middle ground that matters for teams: smart-account wallets and MPC. A smart-account (ERC-4337) wallet is still non-custodial, but its rules are programmable, so it can add social recovery, spending limits, and gas sponsorship. MPC splits key control across parties for institutional key management. We build all three models and help you choose the one that fits your product and your risk posture, rather than defaulting you into custody you did not want.
Can you build an embedded or white-label wallet inside our app?
Yes. An embedded wallet lives inside your product behind a familiar login, so a user signs up with email or a social account and gets a real non-custodial wallet underneath, without ever seeing a seed phrase. You keep your brand and the user relationship. We build these two ways: by integrating a Wallet-as-a-Service provider such as Privy, Web3Auth, or Dynamic when that is the fastest route, or by building the equivalent on your own infrastructure when you need to own it end to end. Either way we wire the wallet into your onboarding, your transaction flows, and the smart-account features (gasless first actions, recovery) that make an in-app wallet usable for people who are not crypto-native.
Do you build smart-account (ERC-4337) wallets?
Yes, and it is a core strength. A smart-account wallet replaces a bare key pair with a programmable contract account, which is what makes gasless onboarding, social recovery without a seed phrase, and scoped session keys possible. We helped build Safe, the smart-account wallet that pioneered account abstraction on EVM, and we have run it in production for years as an official Safe partner, so this is a pattern we have operated at scale rather than a new capability. We ship the account contracts, the signature schemes, the paymaster for gas sponsorship, and the recovery logic, and we harden them before an audit. This work is described in more depth on our account abstraction page; a wallet is usually where those capabilities are put to use.
Can you support MPC or custody providers like Fireblocks?
Yes. For teams that need institutional key management, we integrate Fireblocks or an MPC custodian into your wallet and product, handling the transaction and treasury flows, the policy and authority matrix, and the operations around them, without ever holding your funds ourselves. For on-chain control we deploy and customize Safe, the multisig smart account we helped build, and we have built fully on-chain multisigs outside EVM where a network needed one. The right choice depends on who needs to approve what, and how the keys should be held; we scope that with you rather than pushing a single model. Our Fireblocks and custody integration page covers this in detail.
How long does it take to build a wallet?
It depends on scope. Adding one capability to an existing wallet (embedded login, gasless onboarding, or a custody integration) is typically a matter of weeks, while a full cross-platform wallet with its own backend and mobile apps takes longer. We run every engagement in three phases. Design is a wallet review: we map the flows you need, select the wallet type, and agree the key-management and security model, producing a scoped architecture plan. Build delivers the wallet contracts and signing layer, the backend services, and the app or embedded UI, integrated across your target chains and tested. Launch covers rollout and handover, with the contracts hardened ahead of any external audit. Because we build from wallet infrastructure we already run in production, the timeline is driven by your feature set, not by foundational research, and we confirm it after the review.

Reviewed by Luis Medeiros, Field CTO at Protofire. Last reviewed: July 2026.

Book a call with Alejandro Losa

Schedule a call with our Web3 Solution Architect to receive practical recommendations and a prompt proposal for upgrading your solution.

Protofire 2026. All rights reserved

Message us on Telegram