Struct RawBech32

Source

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

Expand description

Parsed Bech32 structure with raw 5-bit data field.

Use Bech32 instead to automatically encode and decode / 8-bit data.

§Examples

Decode Bech32m string as RawBech32:

use pbech32::{RawBech32, Scheme};

let s = "a1qypqxpq9mqr2hj"; // bech32m string
let got: RawBech32 = 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![0, 4, 1, 0, 6, 1, 0, 5]); // check data

Encode RawBech32 as string:

use pbech32::{bits::convert, RawBech32, Scheme};

let exp = "a1qypqxpq9mqr2hj"; // expected result

// encode 8-bit bytes as vector of 5-bit bytes
let data = convert::<8, 5>(&[1, 2, 3, 4, 5]);

// populate structure
let b = RawBech32 {
  scheme: Scheme::Bech32m, // checksum scheme
  hrp: "a".parse()?, // human-readable part
  data: data, // 5-bit data
};

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

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

use pbech32::{RawBech32, Scheme};

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

let s = "a1qypqxpq9mqr2hj"; // bech32m string
let got = RawBech32::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>

Raw 5-bit data

Note: Use bits::convert() to decode the 5-bit data in this field.

Implementations§

Source §

impl RawBech32

Source

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

Parse string as RawBech32 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::{RawBech32, Scheme};

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

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

Decode string using Scheme::Bech32:

use pbech32::{RawBech32, Scheme};

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

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

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

use pbech32::{RawBech32, Scheme};

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

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