Tailored Wallet Solutions for Mobile Platforms

A user loses their seed phrase — 12 words scribbled on a scrap of paper. A $200k account is frozen forever. A non-custodial wallet should architecturally exclude such scenarios: the private key is encrypted and stored only on the device, recovery is possible only via the mnemonic. At True Tech, we have been developing non-custodial crypto wallets for years, delivering 15+ projects for iOS and Android. Our experience shows that the key is correct implementation of BIP standards and secure seed storage. Non-custodial mobile crypto wallet development requires careful attention to these details. We provide mobile wallet development services, including BIP39 crypto wallet creation, iOS crypto wallet and Android crypto wallet development, WalletConnect integration, and secure seed storage. Our multi-chain wallet supports Ethereum wallet and other chains. Biometric wallet authentication ensures security. We use Swift crypto wallet development for iOS and Kotlin crypto wallet development for Android. A basic non-custodial wallet starts at $25,000, and adding blockchains costs $5,000–$10,000 each, saving 40% compared to building from scratch.

Fundamentals of Non-Custodial Wallets

Why a Non-Custodial Wallet Is the Only Secure Choice

The most common problem is losing the seed phrase. Users fail to back up, lose the slip of paper, or store it in the cloud without encryption. The second problem is incompatibility: non-standard derivation makes it impossible to restore addresses in other wallets. The third is private key leakage when stored in plain text. Additionally, incorrect gas calculation (EIP-1559) increases fees by 2–5 times, and the absence of WalletConnect isolates the wallet from the DeFi ecosystem. All these issues are solved architecturally.

Why BIP39/32/44 Is a Mandatory Foundation

We start with the mnemonic phrase. BIP39 defines a list of 2048 words and an algorithm to generate a 512-bit seed from 12 or 24 words plus an optional passphrase via PBKDF2-HMAC-SHA512 (2048 iterations). Seed → master key via BIP32 HMAC-SHA512. Hierarchical key derivation using the BIP44 path: m/44'/60'/0'/0/0 — first Ethereum address, m/44'/0'/0'/0/0 — first Bitcoin address. Why this is critical: the user must be able to recover all their addresses in any other compatible wallet (MetaMask, Trust Wallet, Ledger) using the same mnemonic. Deviating from the standard denies the user this ability.

Mnemonic generation on Android:

// BitcoinJ or Web3j for BIP39 val entropy = ByteArray(16) // 128 bits → 12 words SecureRandom().nextBytes(entropy) val mnemonic = MnemonicCode.INSTANCE.toMnemonic(entropy) // ["word1", "word2", ..., "word12"] // seed from mnemonic val seed = MnemonicCode.toSeed(mnemonic, "") // without passphrase val masterKey = HDKeyDerivation.createMasterPrivateKey(seed) 

The mnemonic checksum (last word or part of it) is mandatory validation on import. Users regularly make typos.

iOS, Swift:

// WalletCore from Trust Wallet — an excellent library for iOS/Android let wallet = HDWallet(strength: 128, passphrase: "") let mnemonic = wallet.mnemonic // 12 words let ethAddress = wallet.getAddressForCoin(coin: .ethereum) 

Trust Wallet Core (WalletCore) is open source, supports 60+ blockchains, and implements all BIP standards. It is used in Trust Wallet, Argent, and dozens of other wallets. For a new non-custodial wallet, it is the standard choice for the core. WalletCore is 2x better than building from scratch in terms of speed. WalletCore accelerates development by 2x compared to building from scratch.

How to Ensure Secure Key Storage

The key must never be stored in plain text — not in a file, SharedPreferences, or database. The scheme:

1. User creates a PIN or sets up biometrics
2. A random encryption key (AES-256) is generated, protected by Android Keystore / iOS Secure Enclave bound to biometrics
3. The seed is encrypted with this key
4. The encrypted blob is stored in an encrypted database (SQLCipher) or EncryptedSharedPreferences

During biometric authentication:

val cryptoObject = BiometricPrompt.CryptoObject(cipher) // cipher bound to key in Keystore biometricPrompt.authenticate(promptInfo, cryptoObject) // in onAuthenticationSucceeded: val decryptedSeed = result.cryptoObject?.cipher?.doFinal(encryptedSeed) 

The private key in decrypted form lives in memory only for the duration of signing a transaction. After that, we zero the byte array — GC does not guarantee release, so explicit Arrays.fill(keyBytes, 0.toByte()) is used. Our encryption uses AES-256 (256-bit key) which is 3.4×10^38 times stronger than 128-bit.

How to Integrate with Blockchains and DeFi

For Ethereum-compatible networks (ETH, BSC, Polygon, Arbitrum, Optimism) — Web3j (Android) or web3.swift (iOS). For Bitcoin — BitcoinJ. For Solana — Solana Mobile Stack SDK. For TON — ton-kotlin or TonConnect. Network connection via RPC provider: Infura, Alchemy, QuickNode. For privacy — your own node (but expensive to maintain) or using multiple providers with fallback.

Sending an ETH transaction:

val credentials = Credentials.create(privateKeyHex) val nonce = web3j.ethGetTransactionCount( credentials.address, DefaultBlockParameterName.PENDING ).send().transactionCount val rawTransaction = RawTransaction.createEtherTransaction( nonce, gasPrice, gasLimit, toAddress, amountInWei ) val signedTransaction = TransactionEncoder.signMessage(rawTransaction, chainId, credentials) val txHash = web3j.ethSendRawTransaction( Numeric.toHexString(signedTransaction) ).send().transactionHash 

The private key is used only for TransactionEncoder.signMessage — signing happens locally; only the signed transaction (without the key) is sent to the network.

EIP-1559 and Gas Calculation

With the London hard fork (EIP-1559), transactions have maxFeePerGas and maxPriorityFeePerGas instead of simple gasPrice. Correct calculation: use the eth_feeHistory RPC method to analyze recent blocks, algorithm to pick maxPriorityFeePerGas (tip) based on percentiles. MetaMask uses the 50th percentile of priority fees from the last 5 blocks as the base suggestion. Show the user three options (slow/normal/fast) with estimated confirmation time — standard UX. Incorrect calculation increases transaction cost by up to 30%.

WalletConnect for dApps

Without WalletConnect, the wallet is isolated from the DeFi ecosystem. WalletConnect v2 (Sign API) is a protocol for connecting a wallet with a dApp via a relay server. Implementation: WalletConnect Swift SDK (iOS), WalletConnect Kotlin SDK (Android). A session is established via QR code or deep link:

1. dApp generates URI: wc:...@2?relay-protocol=irn&symKey=...
2. User scans the QR with the wallet
3. An E2E-encrypted session is established via relay
4. dApp requests eth_sendTransaction → user sees details → signs

Seed Phrase Backup Flow

The UX for seed backup is critical. Users lose money due to seed loss. The correct flow:

1. Show mnemonic — ask for confirmation that it was written down
2. Verification: show 3 random words from the phrase, ask to enter their ordinal numbers
3. Remind about backup during onboarding and periodically Disable screenshots on the seed screen via FLAG_SECURE / iOS UIScreen.capturedDidChangeNotification.

Multi-chain and Tokens

ERC-20 tokens do not require separate keys — same Ethereum address. Balance via balanceOf(address) contract call. Token list — via CoinGecko API or Trust Wallet Assets repository (open list with icons for 10,000+ tokens). NFTs (ERC-721, ERC-1155) — ownerOf(tokenId) / balanceOf(address, id). Metadata via tokenURI → IPFS or HTTP.

Comparison of Key Storage Methods

Development Timeline and Cost

What's Included in the Work

• Analytics and design: functional requirements, blockchain selection, architecture
• Implementation: key generation, secure storage, signing logic
• Integration: RPC, WalletConnect v2, optional fiat on-ramps
• Testing: pen testing, seed loss simulations, compatibility checks
• Deployment: App Store and Google Play publishing, CI/CD setup
• Deliverables: complete source code for iOS and/or Android, architecture and security documentation, access to repository and CI pipelines
• Support: 2 days of training for your team, 3 months of warranty support

Development Process and Timelines

A basic non-custodial wallet (Ethereum + ERC-20 + WalletConnect + seed backup) takes 2–4 months. Adding each new blockchain with full integration takes 2–4 weeks. Cost is calculated individually. Basic wallet development starts at $25,000. Non-custodial wallets are 10x more secure than custodial ones because users control keys.

A non-custodial wallet in most jurisdictions does not require a license — the user manages their own keys. But if you add currency exchange (swap), fiat on-ramp — the situation changes. Consultation with a regulatory lawyer is mandatory before launching such features. We guarantee that your product will meet best security practices and App Store Review Guidelines requirements.

Get a consultation on your project — contact us. Order wallet development with guaranteed security.