Struct WalletAddress

pub struct WalletAddress { /* private fields */ }

The object representation of a wallet address.

Wallet addresses are structs that act as as an easy manipulation object for wallet addresses. Addresses that come from user input can be verified, and made sure they are correct.

Address can be used as strings or displayed using the Display trait:

use fractal_utils::{WalletAddress, WALLET_ADDRESS_LEN};

let addr = WalletAddress::from_data([0u8; WALLET_ADDRESS_LEN]);
let addr_str = format!("{}", addr);
assert_eq!(addr_str, "fr111111111");

All Fractal wallet addresses start with fr, and then they have a base-58 encoded string representing WALLET_ADDRESS_LEN+2 bytes. The first byte will be 0x00, that the rest bytes until WALLET_ADDRESS_LEN will compose the actual address, while the other two are the checksum. That way addresses coming from user input can be verified:

use std::str::FromStr;
use std::result::Result;
use fractal_utils::{WalletAddress, WALLET_ADDRESS_LEN};

let wallet: Result<WalletAddress, _> = "fr111111111".parse();
assert!(wallet.is_ok());

let wallet: Result<WalletAddress, _> = "fr111111112".parse();
assert!(wallet.is_err());

The checksums are calculated by doing the XOR operation in all the bytes of the wallet address and doing XOR of the checksum’s first byte with the second one for each byte:

let check_addr = [0x00, 0x11, 0x2A, 0x44, 0xCD, 0xFF, 0xE0];
let mut checksum = [0u8; 2];

for b in &check_addr {
    checksum[0] ^= *b;
    checksum[1] ^= checksum[0];
}

assert_eq!(checksum, [0xAD, 0x07]);

Implementations

impl WalletAddress

pub fn from_data(addr: [u8; 7]) -> WalletAddress

Creates a new wallet address from raw data.

This should only be used if the raw input data is verified to be correct, ir it could lead o a false address.

It will panic if the address does not start with byte 0x00.

pub fn get_raw(&self) -> &[u8]

Returns the wallet address bytes.

This could be useful to store the bytes in databases where space can be an issue, or where fast search is required. It does not contain checksums nor any other verification mechanism.

Trait Implementations

impl Clone for WalletAddress

fn clone(&self) -> WalletAddress

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WalletAddress

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

Formats the value using the given formatter.

impl Decodable for WalletAddress

fn decode<__D: Decoder>(d: &mut __D) -> Result<WalletAddress, __D::Error>

Deserialize a value using a Decoder.

impl Display for WalletAddress

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

Formats the value using the given formatter.

impl Encodable for WalletAddress

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

Serialize a value using an Encoder.

impl From<[u8; 7]> for WalletAddress

fn from(other: [u8; 7]) -> WalletAddress

Converts to this type from the input type.

impl FromStr for WalletAddress

type Err = WalletAddressParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<WalletAddress, WalletAddressParseError>

Parses a string s to return a value of this type.

impl Ord for WalletAddress

fn cmp(&self, other: &WalletAddress) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for WalletAddress

fn eq(&self, other: &WalletAddress) -> 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 PartialOrd for WalletAddress

fn partial_cmp(&self, other: &WalletAddress) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for WalletAddress

impl Eq for WalletAddress

impl StructuralPartialEq for WalletAddress