Custom HD Wallet Development for Business: Secure Multi-Chain Solutions
Businesses that need to manage multiple crypto assets across various blockchains often hit the limits of off-the-shelf wallets. You require a custom HD wallet with hierarchical deterministic key generation, multi-chain support, and robust security - without relying on third-party APIs. We build such wallets from scratch, ensuring full control and scalability.
What Problems We Solve
Standard wallets fail when you need:
- Non-standard derivation paths for custom DeFi protocols or NFT custody.
- Multi-chain support without bridging or external services.
- Hardware-backed key storage integrated with your application.
- Audited, production-grade code that passes strict compliance checks.
We address these with a proven architecture based on BIP-32, BIP-39, and BIP-44.
How We Build HD Wallets: Technical Depth
We are a team of blockchain engineers with 12+ years of combined production experience (Ethereum, Solana, Polygon, Arbitrum, Optimism). Over 5 years, we have built over 50 custom wallets for DeFi protocols, centralized exchanges, NFT marketplaces, and enterprise solutions. Our specialists are authors of open-source libraries for BIP-32 and BIP-39, certified in OWASP security standards. Each wallet undergoes a full audit cycle: static analysis (Slither), fuzzing (Echidna), and BIP-44 compliance checks. Professional custom cryptocurrency wallet development can save your project up to 60% on integration costs compared to off-the-shelf solutions.
Hierarchical Deterministic Key Generation
HD wallets rely on three key standards:
- BIP-39 – converts entropy into a mnemonic phrase (12 or 24 words).
- BIP-32 – builds a key tree using CKD function; hardened derivation (with apostrophe in path) protects the master key – even if an attacker obtains a child private key, they cannot recover the parent.
-
BIP-44 – defines unified path format:
m / purpose' / coin_type' / account' / change / index. For example, first Ethereum address:m/44'/60'/0'/0/0.
We use official test vectors from the BIP-39 repository to confirm implementation correctness.
import * as bip39 from "bip39";
import { HDKey } from "@scure/bip32";
import { keccak256 } from "ethereum-cryptography/keccak";
import { secp256k1 } from "ethereum-cryptography/secp256k1";
function generateMnemonic(strength: 128 | 256 = 128): string {
return bip39.generateMnemonic(strength);
}
async function mnemonicToSeed(mnemonic: string, passphrase: string = ""): Promise<Uint8Array> {
if (!bip39.validateMnemonic(mnemonic)) {
throw new Error("Invalid mnemonic");
}
return bip39.mnemonicToSeed(mnemonic, passphrase);
}
| Property | Hardened derivation (') | Non-hardened derivation |
|---|---|---|
| Master key protection | Yes (via HMAC-SHA512 with private key) | No (exposing child key allows computing parent public key) |
| Indices | >2^31 | 0..2^31-1 |
| Typical use | Coin type, account | Change, address index |
Multi-Chain Support
Our wallets support Ethereum, Polygon, Arbitrum, Optimism, Base, BNB Chain, and Solana. CoinType follows BIP-44 (60 for Ethereum, 501 for Solana, etc.). We easily add any EVM-compatible or custom chain by adjusting coin_type and configuring RPC.
interface DerivedAccount {
path: string;
privateKey: Uint8Array;
publicKey: Uint8Array;
address: string;
xpub: string;
}
function deriveAccount(seed: Uint8Array, accountIndex: number = 0, addressIndex: number = 0, coinType: number = 60): DerivedAccount {
const hdKey = HDKey.fromMasterSeed(seed);
const path = `m/44'/${coinType}'/${accountIndex}'/0/${addressIndex}`;
const derived = hdKey.derive(path);
if (!derived.privateKey) throw new Error("Failed to derive private key");
const publicKey = secp256k1.getPublicKey(derived.privateKey, false);
const address = publicKeyToAddress(publicKey);
return { path, privateKey: derived.privateKey, publicKey, address, xpub: derived.publicExtendedKey };
}
Hardware-Grade Key Security
We implement hardware encryption: Secure Enclave (iOS) and Android Keystore. For web versions, we use Web Crypto API with PBKDF2 (600,000 iterations) and AES-256-GCM, meeting current NIST recommendations.
async function encryptKeystore(privateKey: Uint8Array, password: string): Promise<EncryptedKeystore> {
const salt = crypto.getRandomValues(new Uint8Array(32));
const iv = crypto.getRandomValues(new Uint8Array(16));
const passwordKey = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, ["deriveBits", "deriveKey"]);
const encryptionKey = await crypto.subtle.deriveKey({ name: "PBKDF2", salt, iterations: 600_000, hash: "SHA-256" }, passwordKey, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, encryptionKey, privateKey);
return { version: 3, crypto: { ciphertext: Buffer.from(encrypted).toString("hex"), cipher: "aes-256-gcm", kdf: "pbkdf2", kdfparams: { dklen: 32, salt: Buffer.from(salt).toString("hex"), c: 600_000, prf: "hmac-sha256" }, iv: Buffer.from(iv).toString("hex"), mac: "" } };
}
Multi-account and watch-only modes: our wallet supports multiple BIP-44 accounts (by varying account index) and watch-only access via xpub. This allows balance display without private keys – perfect for cold storage monitoring.
class HDWalletManager {
private hdKey: HDKey;
constructor(seed: Uint8Array) { this.hdKey = HDKey.fromMasterSeed(seed); }
getAccount(accountIndex: number): DerivedAccount { /* ... */ }
getAccountXpub(accountIndex: number): string { return this.hdKey.derive(`m/44'/60'/${accountIndex}'`).publicExtendedKey; }
static deriveAddressFromXpub(xpub: string, addressIndex: number): string {
const hdKey = HDKey.fromExtendedKey(xpub);
const derived = hdKey.derive(`m/0/${addressIndex}`);
return publicKeyToAddress(derived.publicKey!);
}
}
Transaction signing: we support EIP-1559 (Ethereum) and legacy transactions, using viem for signing.
async function signTransaction(privateKey: Uint8Array, txParams: { to: string; value: bigint; data: string; chainId: number; nonce: number; maxFeePerGas: bigint; maxPriorityFeePerGas: bigint; gas: bigint }): Promise<string> {
const account = privateKeyToAccount(`0x${Buffer.from(privateKey).toString("hex")}`);
return await account.signTransaction({ type: "eip1559", ...txParams });
}
Real-World Case Study
For one client, we built a wallet supporting 15 networks with custom gas management – delivered in 3 weeks. The solution allowed seamless interaction with all major L2s without external bridges, and the gas optimization reduced transaction costs by 25% on average.
When Do You Need Custom HD Wallet Development?
If your project requires non-standard crypto paths (e.g., for NFT custodial storage or a DeFi aggregator), multi-chain support without external bridges, or hardware integration – off-the-shelf wallets are ineffective. We build the architecture from scratch: you get code that works on all L2s, is library-version independent, and easily extensible.
Our Development Process
- Requirements analysis – determine necessary networks, transaction types, security level (cold/hot storage).
- Architecture design – choose BIP paths, stack (Foundry/Hardhat), encryption scheme.
- Core implementation – mnemonic generation, key derivation, transaction signing.
- Network integration – RPC configuration, EIP-1559 support, multi-chain routing.
- Security & audit – static analysis, fuzzing, OWASP top10 checks.
- Testing – test vector validation, MetaMask/Ledger import, E2E tests.
- Deployment & documentation – CI/CD, API docs, team training.
What’s Included in the Work
When you order custom HD wallet development, you receive:
- Annotated source code (TypeScript / React Native)
- Integration and API documentation
- Access to private repository and CI/CD
- Test suite (unit, integration, e2e)
- Consulting support during integration
- Code warranty (6 months of free adjustments per specification)
Compatibility & Testing
Before release, we run official test vectors from BIP-39 and BIP-32. We verify mnemonic import in MetaMask, Ledger Live, and Trust Wallet.
| Test | Check |
|---|---|
| Import in MetaMask | Same mnemonic → same addresses |
| Import in Ledger Live | Via standard BIP-44 path |
| Import in Trust Wallet | 12/24 words, first address matches |
| BIP-39 test vectors | Official vectors from repository |
Timeline Estimates
Development ranges from 2 weeks for a basic web wallet to 2 months for a multi-platform solution with hardware integration. The exact timeline depends on complexity and feature set – we provide a detailed estimate after our initial analysis.
Ready to Build Your Custom HD Wallet?
Contact us for a consultation – we will prepare the architecture and accurate cost estimate within 2 working days. Order HD wallet development and get a ready product that scales to any blockchain challenge.