Base58 Encoder & Decoder

How Base58 Works

Base58 works similarly to other base-N encodings, but with a specifically chosen alphabet of 58 characters:

123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz

Notice the absence of:

• Number 0 (zero)
• Uppercase letter O (capital o)
• Uppercase letter I (capital i)
• Lowercase letter l (lowercase L)
• Special symbols like + and / (used in Base64)

These characters are deliberately omitted to improve readability and reduce transcription errors.

The Base58 Algorithm

The Base58 encoding process works as follows:

1. Start with binary data (a byte array)
2. Convert the data to a large integer (big-endian)
3. Repeatedly divide the integer by 58, taking the remainder at each step
4. Map each remainder to the corresponding character in the Base58 alphabet
5. Reverse the resulting string to get the final encoding

Additionally, any leading zero bytes in the input are converted to the character '1' in the output (not the value 0).

function encodeBase58(buffer) {
  const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
  
  // Count leading zeros
  let zeros = 0;
  for (let i = 0; i < buffer.length && buffer[i] === 0; i++) {
    zeros++;
  }
  
  // Convert to big integer
  let num = 0n;
  for (let i = 0; i < buffer.length; i++) {
    num = num * 256n + BigInt(buffer[i]);
  }
  
  // Convert to base58
  let result = '';
  while (num > 0) {
    const remainder = Number(num % 58n);
    num = num / 58n;
    result = ALPHABET[remainder] + result;
  }
  
  // Add leading '1's for zero bytes
  for (let i = 0; i < zeros; i++) {
    result = '1' + result;
  }
  
  return result;
}

Common Base58 Variants

Several variants of Base58 exist, each using a slightly different alphabet ordering:

Base58Check and Checksums

Base58Check adds error-detection capabilities to Base58 encoding by appending a 4-byte checksum to the data before encoding. This allows receivers to verify the data hasn't been corrupted or mistyped.

1. Prepend version byte (e.g., 0x00 for Bitcoin addresses)
2. Calculate double SHA-256 hash: SHA256(SHA256(version + data))
3. Take first 4 bytes of this hash as checksum
4. Append checksum to data: version + data + checksum
5. Encode the result with Base58

When decoding, the process is reversed, and the checksum is verified to ensure data integrity.

Base58 in Cryptocurrencies

Bitcoin introduced Base58Check encoding for addresses to make them more user-friendly and error-resistant. A Bitcoin address consists of:

• Version byte (0x00 for mainnet P2PKH addresses)
• RIPEMD-160 hash of the public key
• 4-byte checksum

When these components are combined and Base58-encoded, they result in addresses beginning with "1" (for P2PKH mainnet addresses).

Other cryptocurrencies adapted this approach, often using different version bytes to create distinct address formats:

Implementation Challenges

When implementing Base58 encoding, several challenges must be addressed:

• Large Integer Handling: Base58 encoding requires working with integers larger than those natively supported by most programming languages
• Leading Zeros: Special handling is needed for preserving leading zero bytes
• Performance: Naive implementations can be slow for large inputs due to big integer arithmetic
• Alphabet Consistency: Ensuring the correct alphabet is used for compatibility

Conclusion

Base58 encoding offers a balance between efficiency and human usability. It's particularly valuable in applications where users might need to manually transcribe encoded data, as it reduces the likelihood of errors while maintaining a relatively compact representation. While it has found its most prominent use in cryptocurrencies, Base58 can be useful in any context where human-friendly, compact data representation is needed.