Struct Alphabet

pub struct Alphabet { /* private fields */ }

Prepared Alphabet for EncodeBuilder::with_alphabet and DecodeBuilder::with_alphabet.

Implementations

impl Alphabet

pub const BITCOIN: &'static Self = _

Bitcoin’s alphabet as defined in their Base58Check encoding.

See https://en.bitcoin.it/wiki/Base58Check_encoding#Base58_symbol_chart

pub const MONERO: &'static Self = _

Monero’s alphabet as defined in this forum post.

See https://forum.getmonero.org/4/academic-and-technical/221/creating-a-standard-for-physical-coins

pub const RIPPLE: &'static Self = _

Ripple’s alphabet as defined in their wiki.

See https://wiki.ripple.com/Encodings

pub const FLICKR: &'static Self = _

Flickr’s alphabet for creating short urls from photo ids.

See https://www.flickr.com/groups/api/discuss/72157616713786392/

pub const DEFAULT: &'static Self = Self::BITCOIN

The default alphabet used if none is given. Currently is the BITCOIN alphabet.

pub const fn new(base: &[u8; 58]) -> Result<Self, Error>

Create prepared alphabet, checks that the alphabet is pure ASCII and that there are no duplicate characters, which would result in inconsistent encoding/decoding

let alpha = bs58::Alphabet::new(
    b" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY"
)?;

let decoded = bs58::decode("he11owor1d")
    .with_alphabet(bs58::Alphabet::RIPPLE)
    .into_vec()?;
let encoded = bs58::encode(decoded)
    .with_alphabet(&alpha)
    .into_string();

assert_eq!("#ERRN)N RD", encoded);

Errors

Duplicate Character

let alpha = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
assert_eq!(
    bs58::alphabet::Error::DuplicateCharacter { character: 'a', first: 0, second: 1 },
    bs58::Alphabet::new(alpha).unwrap_err());

Non-ASCII Character

let mut alpha = *b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
alpha[1] = 255;
assert_eq!(
    bs58::alphabet::Error::NonAsciiCharacter { index: 1 },
    bs58::Alphabet::new(&alpha).unwrap_err());

pub const fn new_unwrap(base: &[u8; 58]) -> Self

Same as Self::new, but gives a panic instead of an Err on bad input.

Intended to support usage in const context until Result::unwrap is able to be called.

const ALPHA: &'static bs58::Alphabet = &bs58::Alphabet::new_unwrap(
    b" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY"
);

let decoded = bs58::decode("he11owor1d")
    .with_alphabet(bs58::Alphabet::RIPPLE)
    .into_vec()?;
let encoded = bs58::encode(decoded)
    .with_alphabet(ALPHA)
    .into_string();

assert_eq!("#ERRN)N RD", encoded);

If your alphabet is inconsistent then this will fail to compile in a const context:

const _: &'static bs58::Alphabet = &bs58::Alphabet::new_unwrap(
    b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
);

Trait Implementations

impl Clone for Alphabet

fn clone(&self) -> Alphabet

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Alphabet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for Alphabet