Struct Bech32

Source

pub struct Bech32 {
    pub scheme: Scheme,
    pub hrp: Hrp,
    pub data: Vec<u8>,
}

Expand description

Parsed Bech32 structure.

Use RawBech32 and bits::convert() instead to handle data encoding and decoding manually.

§Examples

Decode string as Bech32:

use pbech32::{Bech32, Scheme};

let s = "a1qypqxpq9mqr2hj"; // bech32m string
let got: Bech32 = s.parse()?; // parse string

assert_eq!(got.scheme, Scheme::Bech32m); // check scheme
assert_eq!(got.hrp.to_string(), "a"); // check hrp
assert_eq!(got.data, vec![1, 2, 3, 4, 5]); // check data

Encode Bech32 as string:

use pbech32::{Bech32, Scheme};

let exp = "a1qypqxpq9mqr2hj"; // expected result

// populate structure
let b = Bech32 {
  scheme: Scheme::Bech32m, // checksum scheme
  hrp: "a".parse()?, // human-readable part
  data: vec![1, 2, 3, 4, 5], // 8-bit data
};

let got = b.to_string(); // convert to string
assert_eq!(got, exp); // check result

Use Bech32::new() to parse a specific scheme:

use pbech32::{Bech32, Scheme};

// expected result
let exp = Bech32 {
  scheme: Scheme::Bech32m, // checksum scheme
  hrp: "a".parse()?, // human-readable part
  data: vec![1, 2, 3, 4, 5], // 8-bit data
};

let s = "a1qypqxpq9mqr2hj"; // bech32m string
let got = Bech32::new(s, Some(Scheme::Bech32m))?; // parse string
assert_eq!(got, exp); // check result

Fields§

§scheme: Scheme

Scheme

Affects checksum encoding.

§hrp: Hrp

Human-readable part

Human-readable prefix containing ASCII characters in the range 33..127.

§data: Vec<u8>

8-bit data

Implementations§

Source §

impl Bech32

Source

pub fn new(s: &str, scheme: Option<Scheme>) -> Result<Self, Err>

Parse string as Bech32 with given scheme.

The difference between this function and str::parse() is that this function allows you to limit parsing to a particular scheme.

Setting the scheme parameter to None enables scheme auto-detection and is equivalent to calling str::parse().

§Example

Decode string using Scheme::Bech32m:

use pbech32::{Bech32, Scheme};

// expected result
let exp = Bech32 {
  scheme: Scheme::Bech32m, // checksum scheme
  hrp: "a".parse()?, // human-readable part
  data: vec![1, 2, 3, 4, 5], // 8-bit data
};

let s = "a1qypqxpq9mqr2hj"; // bech32m string
let got = Bech32::new(s, Some(Scheme::Bech32m))?; // parse string
assert_eq!(got, exp); // check result

Decode string using Scheme::Bech32:

use pbech32::{Bech32, Scheme};

// expected result
let exp = Bech32 {
  scheme: Scheme::Bech32, // checksum scheme
  hrp: "a".parse()?, // human-readable part
  data: vec![1, 2, 3, 4, 5], // 8-bit data
};

let s = "a1qypqxpq9wunxjs"; // bech32m string
let got = Bech32::new(s, Some(Scheme::Bech32))?; // parse string
assert_eq!(got, exp); // check result

Decode string and auto-detect scheme (equivalent to calling str::parse()):

use pbech32::{Bech32, Scheme};

// expected result
let exp = Bech32 {
  scheme: Scheme::Bech32m, // checksum scheme
  hrp: "a".parse()?, // human-readable part
  data: vec![1, 2, 3, 4, 5], // 8-bit data
};

let s = "a1qypqxpq9mqr2hj"; // bech32m string
let got = Bech32::new(s, None)?; // parse string
assert_eq!(got, exp); // check result