High-performance Base58 encoding/decoding library for Go with support for multiple alphabets.

• Fast: Optimized algorithms using chunked processing and lookup tables
• Multiple Alphabets: Built-in support for Bitcoin, Flickr, and Ripple alphabets
• Memory Efficient: Minimal allocations (1-2 allocs for most operations), stack allocation for small inputs
• Zero Dependencies: Pure Go implementation
• Fully Tested: Comprehensive test suite with fuzzing

go get github.com/dozyio/base58

package main

import (
    "fmt"
    "github.com/dozyio/base58"
)

func main() {
    // Encode using Bitcoin alphabet (default)
    data := []byte("Hello, World!")
    encoded := base58.Encode(data)
    fmt.Println(encoded) // 72k1xXWG59fYdzSNoA

    // Decode
    decoded, err := base58.Decode(encoded)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(decoded)) // Hello, World!
}

// Use Flickr alphabet
encoded := base58.EncodeAlphabet(data, base58.FlickrAlphabet)
decoded, err := base58.DecodeAlphabet(encoded, base58.FlickrAlphabet)

// Use Ripple alphabet
encoded = base58.EncodeAlphabet(data, base58.RippleAlphabet)
decoded, err = base58.DecodeAlphabet(encoded, base58.RippleAlphabet)

// Create custom encoding instance
custom := base58.NewEncoding("your58characteralphabetgoesheremakesureitisunique123")
encoded = custom.Encode(data)
decoded, err = custom.Decode(encoded)

Benchmarked on Apple M3 Max against popular Go Base58 libraries:

• mr-tron/base58 v1.2.0
• btcsuite/btcd/btcutil v1.1.6

Memory Allocations (Decode):

Memory Allocations (Encode):

Optimized for typical libp2p peer ID sizes (34-byte SHA-256 multihash):

This library achieves high performance through several optimizations:

1. Hybrid Approach: Automatically switches between optimized algorithms based on input size:
   • Small inputs (< 512 bytes for encode, < 768 bytes for decode): Uses chunked uint64 math with minimal allocations
   • Large inputs (≥ 512/768 bytes): Uses math/big which leverages assembly-optimized big integer operations
   • This hybrid strategy provides the best performance across all input sizes
2. Chunked Processing: Processes input in Base58^5 (encode) and Base58^10 (decode) chunks instead of single bytes
3. Lookup Tables: Pre-computed 2-character lookup table (58^2 = 3,364 entries) for faster output generation
4. Stack Allocation: Uses stack allocation for small inputs to avoid heap pressure
5. Unsafe Pointers: Direct memory access for critical hot paths
6. SIMD-Ready: Byte reversal using bits.ReverseBytes32 for potential hardware acceleration
7. Zero-Copy Strings: Uses unsafe.String to avoid allocations when converting []byte to string
8. Alphabet Caching: Caches encoding instances to avoid rebuilding decode maps

// Encode/Decode with Bitcoin alphabet
func Encode(input []byte) string
func Decode(str string) ([]byte, error)

// Encode/Decode with custom alphabet
func EncodeAlphabet(input []byte, alphabet string) string
func DecodeAlphabet(str string, alphabet string) ([]byte, error)

// Create encoding instance
func NewEncoding(alphabet string) *Encoding

const (
    BTCAlphabet    = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
    FlickrAlphabet = "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
    RippleAlphabet = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"
)

var (
    BTC    = NewEncoding(BTCAlphabet)
    Flickr = NewEncoding(FlickrAlphabet)
    Ripple = NewEncoding(RippleAlphabet)
)

# Run tests
go test -v

# Run benchmarks
go test -bench=. -benchmem

# Run with race detection
go test -race

# Run fuzzing
go test -fuzz=FuzzBase58 -fuzztime=30s

MIT License - see LICENSE file for details

Contributions are welcome! Please feel free to submit a Pull Request.