PROPELOO

CRYPTO WALLET / KEY INFRASTRUCTURE

Build the custody layer your users will trust with real assets.

PROPELOO engineers production-grade crypto wallets — from MPC and multi-sig custody architecture to account abstraction (ERC-4337), hardware wallet integration and white-label wallet products. Key management is not a feature. It is the foundational security decision of every crypto product. Get it wrong and no amount of UI polish will recover the trust of users who lost funds.

Every wallet architecture decision is a permanent tradeoff between security, UX and custody model.

The choice between custodial, non-custodial and MPC wallet architecture is not a technical preference — it is a product and regulatory decision with permanent consequences. A custodial wallet means you hold the keys and bear regulatory liability as a money service business. A non-custodial wallet means the user holds the keys and the product must survive the reality that users lose seed phrases. An MPC wallet distributes the key so neither party holds it fully — but requires a key refresh protocol, network availability and a recovery mechanism that is itself a security surface. There is no universally correct answer. PROPELOO designs the wallet architecture that is correct for your specific custody model, regulatory environment, user base and threat model — before any code is written.

The full wallet engineering stack.

A wallet is not an app with a private key. It is a key management system, transaction signing engine, chain integration layer and user experience product — each with its own engineering requirements.

System Layers

  • Key Management Layer: Key generation, storage, encryption, MPC sharding, hardware security module integration
  • Signing & Transaction Layer: Transaction construction, gas estimation, signature serialisation, multi-chain broadcasting
  • Chain Integration Layer: RPC provider abstraction, multi-chain support, NFT and token indexing, event subscriptions
  • Account Abstraction Layer: ERC-4337 smart contract accounts, bundler integration, paymaster, social recovery
  • Application Layer: Mobile and web UI, WalletConnect v2, dApp browser, notification infrastructure

Core Technical Capabilities

  • MPC Wallet Architecture

    Threshold signature schemes (2-of-3, 3-of-5) using GG18/GG20 or FROST protocols. Key shares distributed across user device, server and optionally a hardware backup — no single party holds the full key.

  • Multi-signature Wallets

    Gnosis Safe integration, custom multisig contracts, M-of-N signer configurations, timelock policies, spending limits and role-based signing authority for institutional custody.

  • Account Abstraction (ERC-4337)

    Smart contract wallets with social recovery, session keys, gas sponsorship via paymasters, batch transactions and custom validation logic. Eliminates seed phrases without sacrificing self-custody.

  • HD Wallet & Key Derivation

    BIP-32/39/44 hierarchical deterministic wallet implementation, multi-account management, cross-chain address derivation from a single seed, secure entropy generation and seed phrase backup systems.

  • Hardware Wallet Integration

    Ledger and Trezor SDK integration, offline signing flows, hardware-backed key confirmation for high-value transactions and hybrid hot/cold signing architectures.

  • Recovery & Backup Systems

    Social recovery via trusted contacts (ERC-4337), Shamir secret sharing for seed backup, encrypted cloud backup with user-controlled keys and time-locked recovery flows.

How we think about wallet architecture.

The wallet is the only product in crypto where a single engineering mistake can mean permanent, irrecoverable loss of user funds. Every architecture decision must be evaluated against its worst-case failure mode.

  • The custody model determines everything

    Custodial, non-custodial and MPC are not interchangeable options — they have fundamentally different regulatory implications, UX constraints and threat models. A custodial wallet requires money transmitter licensing in most jurisdictions. A non-custodial wallet requires users who can manage seed phrases. An MPC wallet requires network availability for every signing operation. Choose the wrong model and you cannot pivot cheaply.

    Axiom:

  • Key storage is the attack surface

    A wallet with perfect UX that stores the private key in AsyncStorage or localStorage is not a wallet — it is a fund transfer to whoever finds the vulnerability. Keys must be stored in the platform secure enclave (iOS Secure Enclave, Android Keystore), encrypted with user authentication and never exposed to JavaScript contexts in plain text.

    Axiom:

  • Recovery must be designed before launch

    What happens when a user loses their phone? Loses their seed phrase? Dies? The recovery mechanism must be designed as part of the initial architecture — not bolted on after users start asking. Every recovery mechanism is itself an attack surface: social recovery can be socially engineered, cloud backup can be compromised, hardware backup can be lost.

    Axiom:

  • Multi-chain is a maintenance commitment

    Supporting 10 chains is not 10x the work at launch. It is 10x the work every time a chain upgrades its RPC interface, changes its fee market (EIP-1559, Solana priority fees), or introduces a new transaction format. Multi-chain wallets require an abstraction layer that isolates chain-specific logic — otherwise every chain upgrade breaks the product.

    Axiom:

The decisions that define a wallet product.

These are not implementation details. They are architectural commitments that define your product, regulatory standing and user trust model.

  • Custodial vs non-custodial vs MPC?

    Impact: This is a regulatory and product decision as much as a technical one. Custodial wallets require legal structure. Non-custodial wallets require users who can handle seed phrases. MPC requires correct cryptographic implementation — a mistake in the threshold signing protocol is catastrophic.

    • Custodial — you hold keys, full UX control, MSB/VASP licensing required, single point of failure
    • Non-custodial — user holds keys, no licensing requirement, seed phrase UX friction, no account recovery
    • MPC (threshold signatures) — distributed key, no seed phrase, requires network for signing, complex to implement correctly
    • Account abstraction (ERC-4337) — smart contract wallet, social recovery, no seed phrase, EVM-only currently
  • Key storage on device?

    Impact: Keys stored outside the platform hardware security module are vulnerable to extraction by a privileged process, backup leak or JavaScript context exposure. The Secure Enclave is not optional for production wallets.

    • iOS Secure Enclave / Android Keystore — hardware-backed, correct choice for production
    • Encrypted AsyncStorage — never acceptable for production key storage
    • Encrypted SQLite with user password — acceptable for low-value wallets with strong password UX
    • Server-side encrypted with user-derived key — required for cloud backup, risk if key derivation is weak
  • Transaction signing architecture?

    Impact: On-device signing with hardware-backed key storage is the correct architecture for self-custody products. MPC is correct for institutional products where device loss must not mean key loss.

    • On-device signing — keys never leave device, offline capability, no server dependency
    • MPC distributed signing — no single key, requires network, 2-of-3 threshold is standard
    • Hardware wallet signing — highest security, requires physical device present
    • Server-assisted signing (custodial) — full UX control, regulatory liability
  • Account abstraction vs EOA?

    Impact: ERC-4337 eliminates seed phrases and enables social recovery — solving the two biggest non-custodial wallet UX problems. The tradeoff is EVM-only support and bundler infrastructure dependency. For consumer wallets targeting mainstream users, AA is the correct architecture.

    • EOA (standard private key account) — universal chain support, seed phrase required, no programmable logic
    • ERC-4337 smart account — social recovery, session keys, gas sponsorship, EVM-only, bundler dependency
    • Hybrid (EOA with AA features via proxy) — complex, fragmented UX, not recommended
  • WalletConnect vs embedded dApp browser?

    Impact: WalletConnect v2 is the industry standard. An embedded dApp browser adds significant maintenance overhead as web standards and dApp architectures evolve. Build WalletConnect first.

    • WalletConnect v2 — universal, works with all dApps, best for standalone wallets
    • In-app dApp browser — full control, works offline, maintenance burden as dApps evolve
    • Both — maximum flexibility, double the maintenance surface
    • Neither — wallet-only product without dApp connectivity
  • Multi-chain architecture?

    Impact: Each non-EVM chain requires a separate key derivation path, signing algorithm implementation and chain-specific transaction format. Solana + EVM is a common pragmatic choice. Bitcoin adds UTXO model complexity. Do not promise chains you cannot maintain.

    • Single chain — simple, fast to build, limits addressable market
    • EVM-only multi-chain — same key, different RPC endpoints, manageable complexity
    • EVM + Solana — different key derivation paths, different signing algorithms, significant complexity
    • Full multi-chain (Bitcoin, EVM, Solana, Cosmos) — maximum reach, maximum maintenance burden

What PROPELOO builds.

  • Consumer Self-Custody Wallet

    Mobile-first non-custodial wallet with biometric unlock, ERC-4337 social recovery, NFT display, token management and WalletConnect v2 for dApp connectivity.

  • Institutional MPC Custody

    Enterprise-grade MPC wallet with 2-of-3 or 3-of-5 threshold signing, role-based transaction approval, audit trails, spending limits and HSM integration for key share storage.

  • Exchange Hot Wallet

    High-throughput custodial hot wallet for exchange withdrawal flows — with transaction batching, fee optimisation, automated sweep to cold storage and real-time balance monitoring.

  • White-label Wallet SDK

    Embeddable wallet SDK for apps that need in-app token management — React Native and web components, customisable UI, key management abstraction and multi-chain support.

  • DeFi Protocol Wallet

    Wallet purpose-built for a DeFi protocol — with protocol-specific transaction builders, LP position management, yield claim automation and governance voting integration.

  • Hardware-backed Signing App

    Mobile signing app that uses iOS Secure Enclave or Android Keystore as the hardware root of trust — combining hardware-grade key security with a consumer-grade UX.

The wallet engineering stack.

Key management, signing and chain integration each require purpose-built libraries. The wrong choice at any layer is a security vulnerability.

  • Key Management

    Stack: iOS Secure Enclave, Android Keystore, tss-lib (GG20 MPC), FROST (Schnorr MPC), Shamir Secret Sharing, BIP-32/39/44

  • Signing & Transactions

    Stack: ethers.js / viem, wagmi, @solana/web3.js, bitcoinjs-lib, ERC-4337 SDK, Safe{Core} SDK

  • Chain Infrastructure

    Stack: Alchemy, Infura, QuickNode, Helius (Solana), Custom RPC load balancer

  • Mobile

    Stack: React Native, Expo (managed workflow), react-native-keychain, react-native-quick-crypto, WalletConnect v2 SDK

  • Backend

    Stack: Node.js, Go (MPC coordinator), Redis (session management), PostgreSQL, AWS KMS, HashiCorp Vault

  • Account Abstraction

    Stack: ERC-4337 EntryPoint, Pimlico (bundler), ZeroDev SDK, Biconomy SDK, Safe{Core}

Wallet security is a system property, not a feature.

Every layer of a wallet system has a distinct attack surface. Security must be designed into each layer independently.

  • Key Extraction Prevention

    Private keys and key shares must never exist in plaintext in memory longer than the signing operation requires. React Native JavaScript contexts are not a secure execution environment for long-lived key material. Keys must be generated inside and never exported from the platform security hardware — Secure Enclave on iOS, StrongBox Keymaster on Android.

  • Side-channel Attacks

    MPC protocols implemented in software are vulnerable to timing attacks if not carefully implemented with constant-time arithmetic. Key derivation functions must use hardware-backed entropy sources. Memory scrubbing after signing operations is required to prevent key material recovery from process memory dumps.

  • Transaction Signing UI

    Transaction simulation before signing prevents blind signing attacks. Users should see a human-readable summary of what a transaction does — not a raw hex payload. Malicious dApps craft transactions that appear to be token approvals but are actually full-balance transfers. WalletConnect sessions must display the requesting dApp domain and require explicit user confirmation.

  • Phishing & Social Engineering

    The most common wallet exploit is not a cryptographic attack — it is a user who was tricked into entering their seed phrase on a phishing site or approving a malicious transaction. Wallet UX must make the legitimate flow obvious and the malicious flow difficult: never prompt for seed phrase except on initial setup, display clear domain verification for WalletConnect sessions, and use biometric confirmation for large transactions.

  • Recovery Mechanism Security

    Every recovery mechanism is an alternative path to key access. Social recovery requires that trusted contacts cannot collude or be compromised simultaneously. Cloud backup requires that the encryption key is derived from user secrets, not stored server-side. Time-locked recovery adds a delay that allows intervention if recovery is triggered without the user's knowledge.

  • Dependency & Supply Chain

    Wallet applications have a large npm dependency tree. A compromised dependency with access to the signing context can silently exfiltrate keys. Dependency pinning, integrity verification, minimal dependency footprint and regular audit of the dependency tree are required. The 2022 event-stream attack demonstrated that widely-used npm packages can be specifically targeted to steal cryptocurrency.

From architecture to production wallet.

  1. 01. Custody Architecture

    Define custody model, key management architecture, recovery strategy and regulatory considerations before any code is written.

  2. 02. Security Design Review

    Threat model the wallet system: key extraction paths, transaction manipulation vectors, recovery abuse scenarios and third-party dependency risks.

  3. 03. Core Key Management

    Implement key generation, secure storage, signing and derivation using platform security hardware. No UI work begins until this layer is reviewed.

  4. 04. Chain Integration

    RPC abstraction layer, multi-chain transaction builders, gas estimation, fee market integration and token/NFT indexing.

  5. 05. Application Layer

    Mobile and web UI, WalletConnect v2, transaction simulation display, notification infrastructure and dApp connectivity.

  6. 06. Security Audit

    Internal security review of key management implementation, smart contract audit for AA wallets, penetration test of the application layer.

  7. 07. Production & Monitoring

    Production deployment with RPC redundancy, transaction monitoring, anomaly detection and incident response playbooks for wallet compromise scenarios.

Crypto wallets we have shipped to production.

Three wallet implementations that handle real user funds today.

  • HD wallet supporting 50+ chains with biometric auth and social recovery

    Challenge: Client needed a single wallet supporting 50+ EVM and non-EVM chains with biometric unlock and a recovery path that did not rely on a seed phrase the user would inevitably lose.

    Architecture: BIP-32 hierarchical deterministic key derivation, per-chain derivation paths, biometric-gated keystore on device, Shamir Secret Sharing for 3-of-5 guardian social recovery, no server-side key storage.

    Outcome: 85,000 active wallets, zero key compromise incidents, 94% recovery success rate via social guardians.

  • Institutional-grade custodial wallet with MPC signing and cold storage

    Challenge: Exchange client needed custodial wallet infrastructure capable of handling institutional volumes with segregated client funds, HSM-backed signing, and a cold storage policy that limited hot wallet exposure.

    Architecture: Hot/warm/cold tier architecture: <5% in hot MPC wallets, 15% in warm multi-sig, 80%+ in cold HSM-backed storage. Per-user virtual accounts over shared on-chain wallets, automated sweeping.

    Outcome: Processing $2.4M daily volume, insurance-eligible custody structure, zero loss of funds in 18 months of operation.

  • Wallet-as-a-Service API platform for neobanks embedding crypto

    Challenge: FinTech client needed to embed crypto wallets into their existing neobank app without rebuilding their core banking infrastructure — wallet creation, funding, sending, and conversion all via API.

    Architecture: REST and gRPC API layer over MPC custody backend, webhook event system for transaction status, abstracted fee management hiding gas complexity from the neobank.

    Outcome: 12 neobanks integrated, 200K end-user wallets provisioned in first 6 months, average wallet creation time 340ms.

Frequently Asked Questions

What is the difference between MPC and multi-sig?

Multi-sig requires M-of-N on-chain signers — each signer has a complete key and the contract enforces the threshold. This is visible on-chain and requires a transaction to change the signer set. MPC distributes the key into shares that are never combined — signing happens as a distributed computation, the resulting signature is indistinguishable from a single-key signature, and no on-chain contract is required. MPC is more flexible and private; multi-sig is simpler and fully on-chain verifiable.

What is ERC-4337 and should we use it?

ERC-4337 is the account abstraction standard that allows smart contract accounts to act as wallets — enabling social recovery, session keys, gas sponsorship and batch transactions without a seed phrase. It is the correct architecture for consumer wallets targeting mainstream users who should not be expected to manage seed phrases. The tradeoffs: EVM-only, requires bundler infrastructure, slightly higher gas cost per transaction. For cross-chain wallets or chains without 4337 support, hybrid architectures are available.

How do you handle seed phrase backup securely?

For non-custodial wallets, seed phrase backup options are: user writes it down (most common, highest loss rate), encrypted cloud backup with user-controlled encryption key (convenient, depends on cloud provider security), Shamir Secret Sharing split across multiple locations, or hardware wallet as backup. ERC-4337 social recovery eliminates the seed phrase entirely for EVM wallets. We recommend designing the backup UX to make secure backup the path of least resistance, not an optional step users skip.

What chains can the wallet support?

EVM chains (Ethereum, Arbitrum, Base, Polygon, BSC, etc.) share key format and signing algorithm — one implementation covers all. Solana uses a different key derivation path and Ed25519 signing. Bitcoin uses a different UTXO model and transaction format. Each non-EVM chain is approximately 4–8 weeks of additional engineering. We recommend launching with the chains where your users actually live rather than listing 50 chains on day one with untested implementations.

How should we handle transaction fees for users?

ERC-4337 paymasters allow you to sponsor gas fees for users (they transact without needing ETH) or accept payment in ERC-20 tokens. This is the cleanest UX solution for onboarding non-crypto-native users. For non-EVM chains, gasless transactions require chain-specific solutions. Fee abstraction significantly increases conversion on first transaction — users who encounter a "you need ETH for gas" message before they can use the product frequently abandon.

What regulatory considerations exist for wallet products?

Non-custodial wallets (user holds keys) generally do not require money transmitter licensing as the developer never controls funds. Custodial wallets (you hold keys) require MSB registration in the US, VASP registration under FATF guidelines, and specific licensing in the EU (MiCA), UK (FCA), UAE (VARA) and other jurisdictions. MPC wallets with server-side key shares occupy a regulatory grey area that varies by jurisdiction. We strongly recommend legal review of your custody model before launch.

Can we add WalletConnect to an existing app?

Yes. WalletConnect v2 has React Native and web SDKs that integrate into existing React Native apps in approximately 2–3 weeks for basic connectivity and 4–6 weeks for full production integration including session management, transaction simulation display and error handling. The main complexity is transaction display — your app must parse and render arbitrary Ethereum transactions in a way users can understand before signing.

How do you secure the backend of a custodial wallet?

Custodial wallet backend security requires: private keys stored in HSM (AWS CloudHSM, Thales, or similar) never in application memory, transaction signing in an isolated signing service with no internet egress, multi-party approval for large withdrawals, rate limiting and anomaly detection on withdrawal requests, immutable audit logs for all signing operations, and regular penetration testing. The backend is the single point of failure — it must be designed with the assumption that every other layer will eventually be compromised.