Custom Non-Custodial Wallet Development from Scratch

Imagine: you launch a DeFi protocol and users complain about fund freezing by a centralized provider. Or you lose confidence in the safety of a seed phrase on the server — one leak is enough to compromise all assets. The solution is a non-custodial wallet where private keys are generated and stored locally, and signing happens offline. We build such wallets from scratch — from architecture selection (HD, MPC, ERC-4337) to deployment in mobile and web environments. With 5+ years of experience in custom crypto wallet development, we have launched more than 30 wallets for EVM networks, including 5 with MPC architecture and 3 with full account abstraction support. Clients range from NFT marketplaces to corporate custodians. We work with Solidity 0.8.x, Rust (Anchor for Solana), Foundry, and Tenderly for simulation.

How Wallet Architecture Affects Security

The choice of architecture determines both protection and user experience.

HD Wallet (BIP-32/44) — the basic scheme for most wallets. A tree of keys is derived from a seed phrase of 12 or 24 words. The user backs up only the mnemonic, and the wallet recovers all accounts. Derivation for Ethereum: m/44'/60'/0'/0/n. If the seed is leaked, all keys are lost — single point of failure.

MPC Wallet (Multi-Party Computation) — the key never exists in its entirety. Signing through threshold signature (GG20, CGGMP21). This eliminates the single point of failure but is more complex to implement and requires more computing resources. According to our audit data, MPC wallets are 3 times safer than HD for storing sums over $1M. Our typical MPC wallet project costs start from $50,000, delivering enterprise-grade security.

Smart Contract Wallet (ERC-4337) — the account is replaced by a smart contract with Account Abstraction. This provides social recovery, batched transactions, gasless operations via Paymaster, and multi-signature without a separate contract. Gas savings for the user can reach 30% when using Paymaster.

How to Ensure Secure Private Key Storage

Each platform requires its own approach:

The seed phrase is encrypted with Argon2id using the user's password before being written to storage. No MD5 or SHA1. In our projects we also use entropy with the ethers.utils.randomBytes library. We guarantee that no key material ever leaves the user's device.

Why Order Non-Custodial Wallet Development from Us?

We don't copy open-source — we adapt the architecture to your use case. MPC wallets are safer than HD for storing large amounts because the key is never assembled in one place. Our experience includes integration with ERC-4337 and BIP-32. With over 30 successful wallet projects and a 5-year track record in blockchain, we bring certified expertise.

A recent case: for an NFT marketplace we implemented HD + Account Abstraction with social recovery and gasless transactions. User retention increased by 40%, and the average fee dropped by 25% (saving users approximately $0.50 per transaction). We completed it in 10 weeks at a cost of $80,000.

EIP-4337 introduces account abstraction without changing the consensus layer. — from Ethereum.org.

What Are the Development Timelines and Costs?

MVP for a single EVM network — from 4 weeks at $30,000. A full product with MPC, NFT support, WalletConnect, and multichain — from 12 weeks at $80,000. The cost is calculated individually after requirements analysis. We provide a guaranteed fixed price after scoping.

Contact us to discuss your project. We will assess the task in 2 business days.

Our Development Process

1. Requirements analysis: determine target platform, required networks, token standards.
2. Design: choose architecture (HD/MPC/SC), design UI/UX and secure storage.
3. Implementation: write smart contracts (Solidity 0.8.x) and client side (React Native / Flutter / Extension).
4. Testing: unit tests, fuzzing (Echidna), transaction simulation (Tenderly).
5. Deployment and audit: deploy contracts, conduct external audit (Certik, Hacken).

For security testing we use static analysis with Slither, fuzzing with Echidna, simulation in Tenderly, and external audit by leading firms. This covers 95% of vulnerabilities. We offer a 6-month security guarantee covering all code we deliver.

What Is Included

• Architecture and API documentation
• Wallet source code from scratch with full ownership
• WalletConnect v2 and Web3 provider integration
• EVM wallet support (Ethereum, BSC, Polygon, Arbitrum, Optimism)
• Automatic ERC-20 and NFT detection
• Transaction simulation before signing
• Client team training (2 sessions)
• Technical support for 1 month after launch
• Deployment scripts and CI/CD pipeline setup
• Access to private git repository and project management board

Typical Mistakes in Self-Development

• Using insecure seed storage (e.g., in SharedPreferences).
• Lack of transaction simulation — the user does not see what they are signing.
• Ignoring EIP-1559: the wallet does not pick the optimal gas price.
• Forgetting multichain compatibility: the user might lose funds when transferring to another network.

Order professional development — and avoid these issues. Get a consultation right now. Our crypto wallet development services are trusted by startups and Fortune 500 clients alike.

We develop crypto wallets turnkey — from custodial solutions for fintech to smart contract accounts on EIP-4337. 5+ years in blockchain development, 40+ projects implemented. Let's examine which architecture to choose for your task and why MPC or Account Abstraction solve the private key problem that MetaMask and classic HD wallets could not close.

Why are classic wallets dangerous for business?

A seed phrase in a browser extension is the only way to restore access. For retail users, this is a barrier to entry (lost phrase = lost money). For corporate treasuries, it is incompatible with compliance (KYC/AML, role model, multisignature). Any single key leak compromises all funds. These risks are built into the architecture, not poor UX.

We eliminate them at the protocol level: MPC wallets (key never fully assembled), smart contract wallets (authorization logic in code), hardware HSM for institutional storage. Details below.

What is the real difference between custodial and non-custodial?

Custodial — the provider stores the private key. User authenticates via email/password/OAuth. Recovery is trivial, KYC/AML built-in. For centralized financial applications, often the only regulatory acceptable option. Risk: single point of failure (e.g., Bitfinex hack — $72M, FTX — $600M+ client funds).

Non-custodial — keys are with the user. Provider has no access to funds. Storage responsibility falls on the user. For 99% of people, this model is unworkable without additional protection — hence MPC.

MPC wallets: the key that doesn't exist

Multi-Party Computation (MPC) is a cryptographic protocol that allows multiple parties to jointly sign a transaction without revealing their partial secrets. The private key never exists in its assembled form.

Standard scheme: 2-of-3 MPC between user (share on device), provider server, and backup cloud storage. Transaction is signed by any two of three parties. Lost phone — recovery via server + cloud. Server compromised — attacker holds only one share, signing impossible.

TSS (Threshold Signature Scheme) is a concrete implementation of MPC for ECDSA/EdDSA. Algorithms: GG18, GG20, CGGMP21 (the latter is faster and has better security proofs). Libraries: tss-lib (Go, from Binance), multi-party-sig (Go, from Coinbase), ZenGo-X/multi-party-ecdsa (Rust).

MPC requires no on-chain changes — to the blockchain, the signature looks like a normal single-key signature. This saves gas and keeps the key management scheme confidential (not published in chain) — unlike multisig.

Account Abstraction (EIP-4337): smart contract as wallet

EIP-4337 completely changes the model: instead of EOA (Externally Owned Account), a smart contract Account is used. Authorization logic is in contract code, not in protocol cryptography. This opens up arbitrary signing logic, social recovery, session keys, sponsored transactions, and batch operations.

How the EIP-4337 stack works:

User → UserOperation → Bundler → EntryPoint contract → Account contract
                                          ↑
                                    Paymaster (optional, pays gas)

UserOperation — a new type of object (not an L1 transaction). Bundler collects UserOps from an alternative mempool, packs them into one transaction, and sends to EntryPoint. EntryPoint calls validateUserOp on the Account contract — Account decides if the signature is valid.

Practical capabilities:

Social recovery. The contract stores a list of guardians (other addresses or a service). Lost key — guardians vote for replacement. Argent has used this scheme since 2020.

Session keys. A temporary key with limited rights: interaction only with a specific contract, until a certain date, up to a certain amount. For GameFi and dApps — user does not sign every micro-transaction.

Paymaster. A third-party contract pays gas for the user. Onboarding pattern: user does not hold ETH, gas is sponsored by dApp or taken from ERC-20 tokens.

Implementations: Safe{Core} Protocol, Biconomy SDK (Stackup), ZeroDev (Kernel), Alchemy (Rundler bundler). EntryPoint v0.6/v0.7 is deployed and active on Ethereum mainnet, Polygon, Arbitrum, Optimism. We guarantee compatibility with the latest contract versions.

What is a Hardware Security Module for corporate wallets?

For treasuries and institutional storage: HSM (Hardware Security Module). The key is generated and never leaves the secure chip. Signing happens inside the HSM. Hardware attestation is supported. Solutions used: AWS CloudHSM, Azure Dedicated HSM, Thales Luna, YubiHSM 2 (for small volumes). Integration via PKCS#11 or cloud-specific API.

A combination of HSM + MPC is optimal for institutional use: key shares are stored in HSMs on different servers/jurisdictions, signing via TSS. This ensures compliance with regulatory requirements (e.g., for crypto custodians).

Integration with dApps: WalletConnect and standards

Any wallet must be able to interact with dApps. Standard: WalletConnect v2 (Sign API): QR code or deep link, peer-to-peer encrypted channel via relay server. For browser extensions: EIP-1193 (Ethereum Provider API).

On the frontend, we use wagmi + viem — one interface for MetaMask, WalletConnect, Coinbase Wallet, injected providers. For Account Abstraction: EIP-5792 (wallet capabilities) and EIP-7677 (paymaster service).

Development process

1. Threat model — who is the user (B2C, B2B, institutional), what operations, what is the acceptable risk model. Architecture depends on this.
2. Selection and design of key storage scheme — MPC, HSM, multisig, or a combination.
3. Development of Account contract (if EIP-4337) or integration of MPC library.
4. Backend — MPC coordination, session management, paymaster service (if needed).
5. Mobile/browser application — UI with WalletConnect integration, biometrics, QR.
6. Integration with dApps — EIP-1193, WalletConnect v2.
7. Audit of contracts and cryptographic implementations — mandatory step. MPC libraries have known vulnerabilities (GG18 susceptible to attack with malicious participant without abort protocol). We use libraries with up-to-date security reviews (CGGMP21). Experience passing audits with Certik, Hacken, Trail of Bits — we have certificates.

What is included in the work (deliverables)

• Source code of smart contracts (Solidity/Rust) with documentation
• Backend MPC coordination service (Go or Rust) with API
• Mobile application (iOS/Android) or browser extension
• Integration with WalletConnect, Ledger/Trezor (if required)
• Preparation for security audit (vulnerability report)
• Administrator and user documentation
• Access to repository, CI/CD, monitoring (Tenderly, Etherscan API)
• Training of your team (2-3 sessions)
• Post-launch support — 1 month

Timeline and cost

Cost is calculated individually for your project. We will estimate within one day — contact us by email or Telegram. We provide a guarantee on code and timeline.

Typical mistakes in crypto wallet development (and how to avoid them)

• Using outdated MPC libraries — GG18 without abort protocol. Choose CGGMP21 or tss-lib with up-to-date audit reports.
• Tight coupling to a single blockchain — not abstracting for L2/sidechains. Use viem/wagmi for cross-chain.
• Ignoring MEV attacks — when using multisig without timelocks. Add tx simulation (Tenderly) and sandwiching protection.
• Lack of fallback recovery mechanism — for Account Abstraction, not setting up social recovery. Include from the first release.

We eliminate these pitfalls at the design stage — for each project, we create a threat model and security checklist.

Need a reliable wallet with no compromises? Get a consultation from our architect — we will analyze your task and propose an architecture with a precise estimate. Leave a request — we will respond within a day.