Saltix / Docs / SplitKey
GitHub
Overview

SplitKey is a zero-trust vanity address generator. It creates custom blockchain addresses with desired suffixes — without ever exposing your private key to the server.

6
Blockchains
EC Point
Addition algorithm
0
Private keys exposed

The core idea is simple: you send only your public key to the server. The server performs a computationally intensive search and returns a small number — a tweak. You apply this tweak to your private key locally, on your device. The resulting key pair produces an address that ends with your desired suffix.

SplitKey supports all major blockchains: TON, Bitcoin, Ethereum, TRON, Solana, and Sui. Each chain uses its native elliptic curve — secp256k1 or Ed25519.

How It Works

SplitKey uses EC (Elliptic Curve) point arithmetic to split the key generation process between client and server. The server performs the search without ever knowing your private key.

The Math Behind It
Elliptic Curve Arithmetic
// Given: user's public key P = privkey * G // Goal: find tweak t such that address(P + t*G) ends with suffix Thread i starts: P[0] = P + i*G Each iteration: P[n+1] = P[n] + (num_threads * G) ← point addition only! Tweak value: t = i + n * num_threads When found: address(P[n]) matches suffix → emit tweak t // Client combines: secp256k1: final_privkey = user_privkey + t (mod n) Ed25519: final_scalar = clamp(SHA-512(seed))[0:32] + t

The key insight: instead of expensive scalar multiplication per iteration, SplitKey uses incremental point addition. Each thread maintains a running point and steps it by a constant offset — making the search orders of magnitude faster than brute-force approaches.

Protocol Flow
End-to-End Flow
Configure Search
Open splitkey.saltix.io, select blockchain and wallet type, enter desired suffix.
Scan QR Code
A QR code appears with a unique session ID. Scan it with Saltix Wallet — your public key is automatically extracted and sent to the server.
Server Searches
The Rust engine iterates through candidates at high speed using incremental EC point addition — orders of magnitude faster than brute-force. Progress is streamed to both web browser and wallet app in real-time.
Tweak Found
When a matching address is found, the server returns the tweak value — a 16-hex-character number (u64). The server never learns your private key.
Apply Locally
The wallet combines your private key with the tweak to produce a new key pair. The new address ends with your desired suffix. A new vanity wallet is created instantly.
Tweak Application by Curve
secp256k1

BTC ETH TRON

new_privkey = (old_privkey + tweak) mod n new_pubkey = new_privkey * G new_address = chain_address(new_pubkey) // Result: valid private key, fully exportable
Ed25519

TON SOL SUI

scalar = clamp(SHA-512(seed)[0:32]) tweaked = scalar + tweak pubkey = tweaked * G // Ed25519 address = chain_address(pubkey) // Result: raw scalar, NOT a seed

Ed25519 caveat: The tweaked scalar is not a valid Ed25519 seed. Backup requires the original seed phrase + tweak value. Both pieces are needed for recovery.

Security Model

SplitKey is built on a zero-trust architecture. The server is treated as an untrusted compute resource — it performs the search but never has access to your private key material.

Server Trust Boundary
Server sees
  • Compressed public key
  • Desired suffix requirements
  • Generated tweak offsets
  • Search progress and speed
Server NEVER sees
  • Private keys
  • Seed phrases (mnemonics)
  • Secret prefix (if used)
  • Final derived key
iOS Security Measures
Client-Side Protection

The Saltix Wallet app implements multiple layers of sensitive data protection:

  • SecureField — double-confirmed input for sensitive values (tweak, prefix)
  • .screenshotProtected() — blur overlay when screen recording or mirroring is detected
  • SecureMemory.wipe() — zeroes out sensitive strings before deallocation
  • Keychain — stored with kSecAttrAccessibleWhenUnlockedThisDeviceOnly
Supported Blockchains

SplitKey supports 6 blockchains across two elliptic curves. Each chain uses optimized address derivation for maximum search speed.

Network Curve Address Format Wallet Types
TON Ed25519 Base64 URL-safe V3R2 V4R2
BTC secp256k1 Base58 / Bech32 Legacy Nested Native Taproot
ETH secp256k1 0x hex (EIP-55) —
TRON secp256k1 T... Base58Check —
SOL Ed25519 Base58 —
SUI Ed25519 0x hex (Blake2b) —

Bitcoin supports 4 address types: Legacy (1...), Nested SegWit (3...), Native SegWit (bc1q...), and Taproot (bc1p...). You can search across all types simultaneously.

Prefix Feature

An optional extra privacy layer for secp256k1 chains (BTC, ETH, TRON). The user splits the tweak into a secret prefix and a server-discovered offset, so the server can't even link the search to a specific public key.

Prefix Flow
Enter Secret Prefix
User enters a hex prefix on the phone (e.g., "A1B2C3D4"). This value never leaves the device.
Compute Adjusted Key
Wallet computes: adjusted_pubkey = pubkey_of(privkey + prefix * G). This adjusted key is sent to the server.
Server Finds Offset
Server searches from the adjusted key and finds an offset. It cannot reverse-engineer the original pubkey or the prefix.
Combine Tweaks
Wallet combines: full_tweak = prefix + offset. Final key: privkey + full_tweak (mod n).

secp256k1 only: The prefix feature is not available for Ed25519 chains (TON, SOL, SUI). Ed25519 key derivation uses clamped scalars and CryptoKit doesn't expose the raw scalar operations needed for prefix adjustment.

Wallet Integration

The Saltix iOS Wallet has deep integration with the SplitKey generator. Two methods are available: QR scanning (primary) and manual tweak entry (advanced).

Method 1: QR Code Scanning

The primary integration method. After configuring the search on splitkey.saltix.io, a QR code is displayed. The Saltix Wallet scans it and handles everything automatically.

QR Payload Format
saltix://vanity?session=550e8400-e29b-41d4-a716-446655440000&host=splitkey.saltix.io

The wallet parses the URL scheme, loads session parameters from the API, displays a confirmation screen, and upon approval — sends the compressed public key to the server. The search begins automatically.

Method 2: Manual Tweak Entry

For users who obtained a tweak from the web interface and want to apply it manually. Available under Add Wallet → From Current Seed → Vanity.

Manual Entry Steps
  1. Select the target blockchain (TON, BTC, ETH, TRON, SOL, SUI)
  2. Enter the 16-character hex tweak (double confirmation required)
  3. Optionally verify the expected vanity address
  4. Wallet creates a new vanity child wallet linked to the parent seed
Wallet Hierarchy

Vanity wallets are always linked to a parent seed wallet via parentWalletID. They appear as children in the wallet switcher, indented with blockchain badges.

Wallet Tree
◆ Root Wallet (seed phrase, multi-chain) parentWalletID = nil ├─ Passphrase Wallet (25th word) parentWalletID = root.id ├─ Vanity TON (SplitKey tweak) parentWalletID = root.id └─ Vanity SOL (SplitKey tweak) parentWalletID = root.id ◆ Imported Key (standalone, single-chain) parentWalletID = nil
API Reference

Two API surfaces are available: the Session API (for QR-based wallet integration) and the Direct API (for programmatic access).

Session API (QR Flow)

Base URL: https://splitkey.saltix.io/api

POST /api/session/create Create search session

Creates a new search session with specified parameters. Returns a session ID for QR code generation. Session expires after 600 seconds.

Request Body
{ "network": "ton", // ton | btc | eth | tron | sol | sui "wallet_type": "v4", // v3 | v4 | legacy | nested | native | taproot "suffix": "cool", // desired suffix (1-12 chars) "case_sensitive": false, "max_results": 5 // 1-10 }
Response
{ "session_id": "550e8400-e29b-41d4-...", "expires_at": 1709150400 }
POST /api/session/:id/pubkey Submit public key

Submits the compressed public key and starts the search. The Rust engine is spawned as a subprocess.

Request Body
{ "pubkey": "02a1b2c3...", // compressed public key "has_prefix": false, "min_offset_length": 1, "device_token": "..." // optional APNs token }
GET /api/session/:id/status Poll session status

Poll for search progress and results. Recommended interval: 1-2 seconds.

Response
{ "session_status": "searching", // waiting_pubkey | searching | completed | expired "checked": 1048576, "speed": 650000, "elapsed": 42.5, "results": [ { "suffix": "cool", "tweak": "0000000000abc123", "address": "UQD...cool" } ] }
POST /api/session/:id/cancel Cancel search

Cancels the running search and terminates the Rust CLI subprocess.

Direct API
POST /api/start-search Direct search launch

Launch a search directly without creating a session. Useful for programmatic access.

Request Body
{ "network": "ton", "wallet_type": "v4", "suffix": "cool", "case_sensitive": false, "pubkey": "02a1b2c3...", "max_results": 5 }
GET /api/task-status/:id Poll task progress

Check the status and results of a running search task.

GET /api/server-stats Server statistics

Returns server statistics: CPU cores, active tasks, load average.

Performance

SplitKey achieves high throughput by using incremental EC point addition instead of full scalar multiplication. Performance varies by blockchain due to different hashing algorithms.

Why SplitKey is faster

Traditional brute-force requires full key derivation on every iteration: PBKDF2 (2048 rounds) → BIP32 derivation → scalar multiplication → address encoding. This is computationally expensive.

SplitKey replaces all of that with a single EC point addition per iteration — a dramatically cheaper operation. The result is orders of magnitude faster search, with actual speed depending on your hardware and the target blockchain.

Search Complexity

The number of candidates to check grows exponentially with suffix length. Each additional character multiplies the search space by the character set size of the address encoding.

Suffix Length Difficulty Hex (ETH, SUI) Base58/64 (TON, BTC, SOL)
1 charTrivial16~38-58
2 charsVery fast256~1.4K-3.4K
3 charsFast4,096~55K-195K
4 charsModerate65,536~2M-11M
5 charsSlow1,048,576~79M-650M

Tip: For best results, use 2-3 character suffixes — they are found within seconds to minutes. Longer suffixes grow exponentially in search time.