Struct Encoder

pub struct Encoder<'hrp, I, Ck>
where
    I: Iterator<Item = Fe32>,
    Ck: Checksum,
{ /* private fields */ }

The Encoder builds iterators that can be used to encode field elements into a bech32 address.

Construct the encoder by calling Fe32IterExt::with_checksum on an iterator of field elements, optionally prefix the data with a witness version, and then get the encoding as either a stream of characters (Encoder::chars) or a stream of field elements (Encoder::fes).

Examples

use bech32::{Bech32, ByteIterExt, Fe32IterExt, Hrp};

let data = [0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4];

let hrp = Hrp::parse("abc").expect("bc is valid hrp string");
let chars = data
    .iter()
    .copied()
    .bytes_to_fes()
    .with_checksum::<Bech32>(&hrp)
    .chars();

Implementations

impl<'hrp, I, Ck> Encoder<'hrp, I, Ck>

where I: Iterator<Item = Fe32>, Ck: Checksum,

pub fn new(data: I, hrp: &'hrp Hrp) -> Encoder<'hrp, I, Ck>

Constructs a new bech32 encoder.

pub fn with_witness_version(self, witness_version: Fe32) -> Encoder<'hrp, I, Ck>

Adds witness_version to the encoder (as first byte of encoded data).

Note, caller to guarantee that witness version is within valid range (0-16).

pub fn chars(self) -> CharIter<'hrp, I, Ck>

Returns an iterator that yields the bech32 encoded address as field ASCII characters.

pub fn bytes(self) -> ByteIter<'hrp, I, Ck>

Returns an iterator that yields the bech32 encoded address as field ASCII characters, as byte values.

pub fn fes(self) -> Fe32Iter<'hrp, I, Ck>

Returns an iterator that yields the field elements that go into the checksum, as well as the checksum at the end.

Each field element yielded has been input into the checksum algorithm (including the HRP as it is fed into the algorithm).

Trait Implementations

impl<'hrp, I, Ck> Clone for Encoder<'hrp, I, Ck>

where I: Clone + Iterator<Item = Fe32>, Ck: Clone + Checksum,

fn clone(&self) -> Encoder<'hrp, I, Ck>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'hrp, I, Ck> PartialEq for Encoder<'hrp, I, Ck>

where I: PartialEq + Iterator<Item = Fe32>, Ck: PartialEq + Checksum,

fn eq(&self, other: &Encoder<'hrp, I, Ck>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'hrp, I, Ck> Eq for Encoder<'hrp, I, Ck>

where I: Eq + Iterator<Item = Fe32>, Ck: Eq + Checksum,

impl<'hrp, I, Ck> StructuralPartialEq for Encoder<'hrp, I, Ck>

where I: Iterator<Item = Fe32>, Ck: Checksum,