Kobe

no_std-compatible Rust toolkit for multi-chain HD wallet derivation — one BIP-39 seed, twelve networks, zero hand-written cryptography, cross-implementation KATs.

Kobe derives standards-compliant accounts and addresses for Aptos, Bitcoin, Ethereum, Solana, Cosmos, Tron, Sui, TON, Filecoin, Spark, XRP Ledger, and Nostr (NIP-06 / NIP-19) from a single BIP-39 mnemonic. It layers thin wrappers around bip39, bip32, bitcoin, k256, and ed25519-dalek on top of a unified Wallet + Derive trait surface; every library crate builds under no_std + alloc, mnemonics and private keys wrap in Zeroizing<T> and wipe on drop, and every chain's pipeline is pinned against independent reference implementations (bitcoinjs-lib, @ton/core, @noble/hashes, NIP-06 official vectors, ethanmarcuss/spark-address, …).

See also signer — the companion transaction-signing toolkit that consumes kobe's derived accounts via Signer::from_derived.

Quick Start

Install the CLI

Shell (macOS / Linux):

curl -fsSL https://sh.qntx.fun/kobe | sh

PowerShell (Windows):

irm https://sh.qntx.fun/kobe/ps | iex

Or via Cargo:

cargo install kobe-cli

CLI Usage

# Generate new wallets (default: 12-word English mnemonic, 1 account)
kobe btc    new                              # P2WPKH (Native SegWit), mainnet
kobe btc    new -a taproot -w 24 -c 5        # 5 Taproot addresses, 24-word mnemonic
kobe evm    new                              # Ethereum (MetaMask-compatible)
kobe evm    new --style ledger-live -c 3     # Ledger Live layout, 3 accounts
kobe svm    new                              # Solana (Phantom / Backpack / Solflare)
kobe cosmos new                              # Cosmos Hub (`cosmos1…`)
kobe aptos  new                              # Aptos
kobe sui    new                              # Sui
kobe ton    new                              # TON wallet v5r1 (UQ… non-bounceable)
kobe ton    new --bounceable                 # TON bounceable (EQ…), smart-contract style
kobe ton    new --testnet --workchain -1     # TON testnet masterchain
kobe ton    new --style ledger-live          # TON Ledger Live path
kobe tron   new                              # Tron (base58check `T…`)
kobe fil    new                              # Filecoin (`f1…` secp256k1)
kobe spark  new                              # Spark (Bitcoin L2), bech32m `spark1…`
kobe spark  new --network testnet            # Spark testnet (`sparkt1…`)
kobe xrpl   new                              # XRP Ledger classic `r…`
kobe nostr  new                              # Nostr NIP-06 (`nsec` / `npub`, NIP-19)

# Import from an existing mnemonic
kobe evm    import -m "abandon abandon ... about"

# JSON output — stable, script- and agent-friendly
kobe evm    new --json

Every chain subcommand accepts the shared flags -w/--words, -c/--count, -p/--passphrase, and --qr through a flattened SimpleArgs group, so ergonomics stay consistent across the 12 networks.

Library Usage

use kobe::prelude::*;     // Wallet, Derive, DeriveExt, DerivationStyle trait, ...
use kobe::evm::Deriver;   // or kobe::btc, kobe::svm, kobe::cosmos, ...

// Import from mnemonic
let wallet = Wallet::from_mnemonic(
    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
    None,  // optional passphrase
)?;

// Derive addresses (accessor methods — fields are private for zeroization safety)
let eth = kobe::evm::Deriver::new(&wallet).derive(0)?;
let btc = kobe::btc::Deriver::new(&wallet, kobe::btc::Network::Mainnet)?.derive(0)?;
let sol = kobe::svm::Deriver::new(&wallet).derive(0)?;

println!("ETH: {}", eth.address());  // 0x9858EfFD232B4033E47d90003D41EC34EcaEda94
println!("BTC: {}", btc.address());  // bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu
println!("SOL: {}", sol.address());  // HAgk14JpMQLgt6rVgv7cBQFJWFto5Dqxi472uT3DKpqk

// Chain-specific extensions via newtypes: `BtcAccount` extends `DerivedAccount`
// with `private_key_wif()`, `address_type()`, `bip32_path()`; `SvmAccount`
// exposes `keypair_base58()`. Both `Deref` to the unified `DerivedAccount`.
println!("BTC WIF: {}", btc.private_key_wif().as_str());

String-path entry points are uniform across every chain. Bitcoin additionally exposes an explicit-type escape hatch for non-standard paths:

use kobe::btc::{AddressType, Deriver, Network};

let deriver = Deriver::new(&wallet, Network::Mainnet)?;
let p2wpkh = deriver.derive_at("m/84'/0'/0'/0/0")?;                    // infer type from purpose
let taproot = deriver.derive_at("m/86'/0'/0'/0/0")?;                   // infer type from purpose
let custom  = deriver.derive_at_with("m/7'/0'/0'/0/0", AddressType::P2tr)?; // non-standard purpose

DerivationStyle is a shared trait implemented by every chain's style enum. kobe::prelude::* brings it into scope so style.path(i) / style.name() work directly:

use kobe::prelude::*;
use kobe::evm::DerivationStyle;

let style: DerivationStyle = "ledger-live".parse()?;           // FromStr
assert_eq!(style.path(0), "m/44'/60'/0'/0/0");                 // trait method
for variant in <DerivationStyle as kobe::DerivationStyle>::all() {
    println!("{variant}: {}", variant.path(0));
}

// Generate new wallet
let wallet = Wallet::generate(12, None)?;  // 12-word mnemonic
println!("Mnemonic: {}", wallet.mnemonic());

Supported Chains

* Cosmos coin type defaults to 118; Terra (330), Secret (529), Kava (459), and custom chains are selectable via ChainConfig. † Spark purpose 8797555 is Spark-specific (SHA-256("spark") truncated), not a BIP-44 assignment.

Design

• 12 chains — Aptos, Bitcoin, Ethereum, Solana, Cosmos, Tron, Sui, TON, Filecoin, Spark, XRP Ledger, Nostr — one BIP-39 seed
• Zero hand-written cryptography — bip39 for mnemonic ↔ entropy, bip32 / bitcoin for BIP-32 secp256k1, k256 for secp256k1 encodings, ed25519-dalek for SLIP-10 Ed25519; hashing via sha2 / sha3 / blake2 / ripemd; encoding via bech32 / bs58
• Unified derivation contract — shared Derive trait with an associated Account type + shared DerivationStyle trait; every chain has typed public keys via DerivedPublicKey, one shared DeriveError, and one shared ParseDerivationStyleError
• Consistent entry points — derive / derive_with / derive_at / derive_at_with across every chain (Bitcoin's structured path also available as derive_structured)
• HD standards — BIP-32, BIP-39, BIP-44 / 49 / 84 / 86, SLIP-10, NIP-06, NIP-19
• Derivation styles — Standard, Ledger Live, Ledger Legacy, Trust, Phantom, Backpack, Tonkeeper — with FromStr aliases and an accepted-token diagnostic on ParseDerivationStyleError
• Cross-implementation KATs — every chain is pinned against independent references (bitcoinjs-lib, @ton/core, @noble/hashes, NIP-06 official vectors, ethanmarcuss/spark-address, BIP-84 / BIP-86 / EIP-55 / SLIP-10 test vectors) — no self-confirming dumps
• no_std + alloc — every library crate compiles on thumbv7m-none-eabi under CI; embedded / WASM ready
• Security hardened — mnemonics, seeds, private keys, WIFs, nsecs, and Solana keypairs wrapped in Zeroizing<T>; no key material is logged or persisted
• Signer integration — signer consumes every DerivedAccount / BtcAccount / SvmAccount / NostrAccount via Signer::from_derived behind its kobe feature flag
• Strict linting — Clippy pedantic + nursery + correctness (deny), rust_2018_idioms deny, zero warnings on nightly

Crates

See crates/README.md for the full crate table, dependency graph, and feature flag reference.

Security

This library has not been independently audited. Use at your own risk.

• Mnemonics, seeds, and derived private keys wrapped in zeroize — wiped from memory on drop
• Chain-specific secret encodings (BTC WIF, Nostr nsec, Solana 64-byte keypair) are wrapped in Zeroizing<String> / Zeroizing<[u8; N]>
• Random generation uses the OS-provided CSPRNG via getrandom; Wallet::generate_in_with accepts a caller-supplied CryptoRng on embedded / WASM targets where OS entropy is unavailable
• secp256k1 contexts are cached on Deriver to avoid the ~768 KB per-call setup cost
• Environment-variable mutation and std::mem::{transmute, forget} are denied at the lint level
• No key material is logged or persisted by the workspace

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
• MIT License (LICENSE-MIT or https://opensource.org/licenses/MIT)

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project shall be dual-licensed as above, without any additional terms or conditions.

A QNTX open-source project.

Code is law. We write both.