Bech32

Bech32 is an address encoding scheme specifically designed for cryptocurrencies, most notably adopted by Bitcoin for Segregated Witness (SegWit) addresses (P2WPKH and P2WSH). It was introduced to replace the older Base58Check encoding due to several advantages.

Key Features and Advantages of Bech32:
1. Improved Error Detection: Bech32 incorporates a strong checksum (using a Bose-Chaudhuri-Hocquenghem or BCH code) that can detect all single-character errors and most multi-character errors. This significantly reduces the risk of sending funds to a wrong address due to transcription mistakes.
2. Case-Insensitivity: All valid Bech32 characters are lowercase alphanumeric. This eliminates ambiguity that could arise from mixed-case Base58Check addresses and simplifies user experience as addresses can be typed or displayed in any case (though canonical representation is lowercase) without losing validity.
3. Human-Readable Part (HRP): Each Bech32 address starts with a Human-Readable Part, which is a prefix (e.g., "bc" for Bitcoin mainnet, "tb" for Bitcoin testnet, "ltc" for Litecoin mainnet). This HRP clearly indicates the network or type of currency the address belongs to, making it harder to accidentally send coins across different chains.
4. Defined Character Set: Bech32 uses a custom 32-character alphabet (0-9, a-z excluding 'b', 'i', 'o', 'l') that is designed to minimize visual ambiguity and prevent common transcription errors. These characters are chosen to avoid confusion with similar-looking characters (e.g., '1' and 'l', '0' and 'o').
5. Efficient Encoding: It encodes data in 5-bit chunks, which is more efficient for typical cryptographic hashes (often 20 or 32 bytes, which are multiples of 5 bits when converted to 8-bit bytes) compared to Base58's variable-length encoding.
6. Separator: A '1' character separates the HRP from the data part of the address.

Structure of a Bech32 Address:
An address consists of three main parts:
* Human-Readable Part (HRP): e.g., `bc`
* Separator: `1`
* Data Part: The encoded payload (script public key hash or script hash) and the 6-character checksum. The data part uses a 32-character alphabet.

Example: `bc1q…` (Bitcoin SegWit address)

Bech32 improves upon older encoding schemes by offering superior error detection, better human readability, and a more robust design against common user errors, making it a safer and more user-friendly standard for cryptocurrency addresses.

use bech32::{self, FromBase32, ToBase32, Variant};

fn main() {
    // --- Encoding Example ---
    let hrp = "bc"; // Human-Readable Part for Bitcoin mainnet
    let data_bytes = hex::decode("751e76e8199196d454941c45d1b3a323f1433bd6").expect("Invalid hex string");

    // Convert 8-bit bytes to 5-bit base32 groups
    let data_base32 = data_bytes.to_base32();

    match bech32::encode(hrp, data_base32, Variant::Bech32) {
        Ok(encoded_address) => {
            println!("Encoded Address: {}", encoded_address);
            // Expected output: bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4
        },
        Err(e) => eprintln!("Encoding error: {:?}", e),
    }

    // --- Decoding Example ---
    let address_to_decode = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4";

    match bech32::decode(address_to_decode) {
        Ok((decoded_hrp, data_base32, variant)) => {
            println!("\nDecoded HRP: {}", decoded_hrp);
            println!("Decoded Variant: {:?}", variant);

            // Convert 5-bit base32 groups back to 8-bit bytes
            match Vec::<u8>::from_base32(&data_base32) {
                Ok(decoded_bytes) => {
                    println!("Decoded Data (bytes): {}", hex::encode(&decoded_bytes));
                    // Expected output: 751e76e8199196d454941c45d1b3a323f1433bd6
                },
                Err(e) => eprintln!("Data conversion error: {:?}", e),
            }
        },
        Err(e) => eprintln!("Decoding error: {:?}", e),
    }
}