Technical Specifications for LanaCoin Address and Private Key Generation

by

1. Overview

LanaCoin (symbol: LANA) uses cryptographic standards similar to Bitcoin, with specific prefixes and parameters defined in its chain configuration. The process involves generating a secure private key, deriving the public key, and encoding both with checksums using Base58Check.

2. Key Parameters

From the LanaCoin configuration:
  • Address Prefix (pubKeyHash): 0x30 (decimal 48) → Addresses start with L
  • Script Hash Prefix: 0x05
  • WIF Private Key Prefix: 0xB0 (decimal 176) → WIF keys start with 6
  • Extended Keys:
    • Public: 0x0488B21E
    • Private: 0x0488ADE4
  • Elliptic Curve: secp256k1
  • Encoding: Base58Check
  • Checksum: First 4 bytes of double SHA-256 hash
[github.com]

3. Private Key Generation

  • Generate a 256-bit random number using a cryptographically secure RNG.
  • Encode in Wallet Import Format (WIF):
    1. Prefix the raw private key with 0xB0.
    2. Compute double SHA-256 of the prefixed key.
    3. Append the first 4 bytes of the hash as checksum.
    4. Encode the result using Base58Check.
  • Result: WIF string starting with 6.
[offlinelana.org]

4. Public Key Derivation

  • Use secp256k1 to derive the public key from the private key.
  • Format: Uncompressed (prefix 0x04 followed by X and Y coordinates).

5. Address Generation

  • Hash the public key:
    1. Apply SHA-256.
    2. Apply RIPEMD-160 to the result → pubKeyHash.
  • Prefix pubKeyHash with 0x30.
  • Compute checksum:
    1. Double SHA-256 of the prefixed hash.
    2. Take first 4 bytes as checksum.
  • Append checksum and encode using Base58Check.
  • Result: Address starting with L.
[safelana.com]

6. Checksum Details

  • Double SHA-256:
    • First hash: SHA256(data)
    • Second hash: SHA256(first_hash)
  • Checksum: First 4 bytes of second hash.
  • Used in both WIF and address encoding.

7. Example Output

  • Private Key (WIF): 6vdHQgXZ8S7eArxbzDNVgL2rbixtjzCkFWWbrMm545R5f8s4C59 or T5pZxYd29wc5t9aeVMGAM5PE5tesxMRJS9oA2wVxLPyjHVQ6a94G
  • Address: LU7nJCkKV6jJK4NdmsC3xuPYEr4TTxd7x9
[offlinelana.org]
The fact that dumpprivkey from the LanaCoin Qt wallet outputs something like:

T5pZxYd29wc5t9aeVMGAM5PE5tesxMRJS9oA2wVxLPyjHVQ6a94G

means the desktop wallet is not using the WIF prefix 0xB0 for private keys as originally assumed. Instead, it uses a different prefix that encodes to T in Base58Check. This is similar to how some forks (e.g., Litecoin, Dogecoin) use different prefixes for WIF keys.

✅ What This Tells Us

  • LanaCoin’s address prefix is still 0x30 (addresses start with L).
  • The private key prefix for WIF is not 0xB0, but something that maps to T in Base58.
    Likely candidates:

    • 0xB0 → 6 (Bitcoin-like)
    • 0xB0 was assumed from old docs, but the actual code may define SECRET_KEY differently (e.g., 0xB0 changed to 0xB0 + offset or 0xB0 replaced by 0xB0 for testnet vs mainnet).
  • The wallet uses Base58Check encoding, so the process is the same, only the prefix differs.

✅ Why Does It Start With T?

Base58 encoding of the prefix byte determines the first character. For LanaCoin:
  • If prefix = 0xB0 → starts with 6
  • If prefix = 0xB0 + something or 0xB0 replaced by 0xB0 → could start with T
Your example strongly suggests the prefix is 0xB0 or higher, because T is in the Base58 alphabet after 6.
✅ What This Means for You

  • Yes, a LanaCoin private key can start with T if that’s what the official wallet outputs.
  • The encoding process is still:
    • Prefix byte (specific to LanaCoin)
    • Private key
    • Double SHA-256 checksum
    • Base58Check encoding

✅ Explanation:

  • SECRET_KEY = 65 (0x41)
  • When encoded in Base58Check, this prefix maps to T as the first character.
    Why? Because Base58 encoding of a byte value 0x41 falls in the range that starts with T.

✅ Mapping to Base58:

  • Base58 alphabet: 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
  • Position of T in Base58:
    T is the 30th character in the alphabet.
  • Prefix 0x41 (decimal 65) → after Base58 encoding with checksum, the first character becomes T.

✅ So the process is:

  • Prefix byte = 0x41 (decimal 65)
  • Private key (32 bytes)
  • Double SHA-256 checksum (4 bytes)
  • Base58Check encoding → WIF key starts with T
This matches what you observed with dumpprivkey output from the LanaCoin Qt wallet.
Here is the exact prefix value from the LanaCoin source code (chainparams.cpp):

// Base58 prefixes
base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 48);   // Addresses start with ‘L’
base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 5);
base58Prefixes[SECRET_KEY]     = std::vector<unsigned char>(1, 65);   // Private keys start with ‘T’
base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
✅ Key Detail:
  • SECRET_KEY = 65 (0x41)
    This is the prefix for LanaCoin private keys in WIF format. When encoded with Base58Check, this prefix produces WIF keys starting with T, exactly as you observed in the Qt wallet output.

8. Security Considerations

  • Always use a secure RNG for private key generation.
  • Never expose private keys online.
  • Validate addresses and keys using checksum verification before use.