use crate::codec::{base64_decode, crc16, decode_hex};
use crate::Error;
const ADDRESS_TAG: u8 = 0x11;
const TEST_ONLY: u8 = 0x80;
const NON_BOUNCEABLE: u8 = 0x40;
#[derive(Debug, Clone)]
pub struct Address {
workchain: i32,
account_id: [u8; 32],
bounceable: bool,
test_only: bool,
}
impl Address {
pub fn parse(s: &str) -> Result<Address, Error> {
if let Some((workchain, account)) = s.split_once(':') {
return Self::parse_raw(s, workchain, account);
}
Self::parse_user_friendly(s)
}
fn parse_raw(whole: &str, workchain: &str, account: &str) -> Result<Address, Error> {
let workchain: i32 = workchain
.parse()
.map_err(|_| Error::Address(format!("invalid workchain in `{whole}`")))?;
let account_id: [u8; 32] = decode_hex(account)
.and_then(|bytes| bytes.try_into().ok())
.ok_or_else(|| {
Error::Address(format!("account id is not 32 hex bytes in `{whole}`"))
})?;
Ok(Address {
workchain,
account_id,
bounceable: true,
test_only: false,
})
}
fn parse_user_friendly(s: &str) -> Result<Address, Error> {
let raw: [u8; 36] = base64_decode(s)
.and_then(|bytes| <[u8; 36]>::try_from(bytes).ok())
.ok_or_else(|| Error::Address(format!("not a 36-byte user-friendly address: `{s}`")))?;
let stored = [raw[34], raw[35]];
if crc16(&raw[..34]).to_be_bytes() != stored {
return Err(Error::Address(format!(
"address checksum mismatch in `{s}`"
)));
}
let tag = raw[0];
if tag & !(TEST_ONLY | NON_BOUNCEABLE) != ADDRESS_TAG {
return Err(Error::Address(format!(
"unknown address tag {tag:#04x} in `{s}`"
)));
}
let workchain = i32::from(raw[1] as i8);
let mut account_id = [0u8; 32];
account_id.copy_from_slice(&raw[2..34]);
Ok(Address {
workchain,
account_id,
bounceable: tag & NON_BOUNCEABLE == 0,
test_only: tag & TEST_ONLY != 0,
})
}
#[must_use]
pub fn workchain(&self) -> i32 {
self.workchain
}
#[must_use]
pub fn account_id(&self) -> &[u8; 32] {
&self.account_id
}
#[must_use]
pub fn is_bounceable(&self) -> bool {
self.bounceable
}
#[must_use]
pub fn is_test_only(&self) -> bool {
self.test_only
}
}
impl PartialEq for Address {
fn eq(&self, other: &Address) -> bool {
self.workchain == other.workchain && self.account_id == other.account_id
}
}
impl Eq for Address {}
impl std::hash::Hash for Address {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.workchain.hash(state);
self.account_id.hash(state);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
#[test]
fn parses_the_raw_form() {
let a =
Address::parse("-1:3333333333333333333333333333333333333333333333333333333333333333")
.unwrap();
assert_eq!(a.workchain(), -1);
assert_eq!(a.account_id(), &[0x33; 32]);
}
#[test]
fn parses_a_real_user_friendly_address() {
let a = Address::parse("EQD8uRo6OBbQ97jCx2EIuKm8Wmt6Vb15-KsQHFLbKSMiYM0w").unwrap();
assert_eq!(a.workchain(), 0);
assert_eq!(
hex(a.account_id()),
"fcb91a3a3816d0f7b8c2c76108b8a9bc5a6b7a55bd79f8ab101c52db29232260"
);
}
#[test]
fn the_raw_and_user_friendly_forms_agree() {
let raw =
Address::parse("-1:3333333333333333333333333333333333333333333333333333333333333333")
.unwrap();
let friendly = Address::parse("Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vF").unwrap();
assert_eq!(raw, friendly);
}
#[test]
fn rejects_a_corrupted_checksum() {
let corrupted = "Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vG";
assert!(matches!(Address::parse(corrupted), Err(Error::Address(_))));
}
#[test]
fn one_account_has_one_user_friendly_spelling() {
let real = "EQD8uRo6OBbQ97jCx2EIuKm8Wmt6Vb15-KsQHFLbKSMiYM0w";
assert!(Address::parse(real).is_ok());
for extra in ["A", "z", "9", "-", "_", "=", "=A"] {
let padded = format!("{real}{extra}");
assert!(
matches!(Address::parse(&padded), Err(Error::Address(_))),
"`{padded}` parsed as an address"
);
}
}
#[test]
fn an_address_tag_is_read_rather_than_assumed() {
let account = [0x33; 32];
let packed = |tag: u8| {
let mut raw = vec![tag, 0xff];
raw.extend_from_slice(&account);
raw.extend_from_slice(&crc16(&raw).to_be_bytes());
base64_encode(&raw)
};
for (tag, bounceable, test_only) in [
(0x11, true, false),
(0x51, false, false),
(0x91, true, true),
(0xd1, false, true),
] {
let address = Address::parse(&packed(tag)).expect("a tag the format defines");
assert_eq!(address.workchain(), -1);
assert_eq!(address.is_bounceable(), bounceable);
assert_eq!(address.is_test_only(), test_only);
assert_eq!(
address,
Address::parse(
"-1:3333333333333333333333333333333333333333333333333333333333333333"
)
.unwrap()
);
}
for tag in [0x00, 0xff, 0x12, 0x21] {
assert!(
matches!(Address::parse(&packed(tag)), Err(Error::Address(_))),
"tag {tag:#04x} was accepted"
);
}
}
fn base64_encode(bytes: &[u8]) -> String {
const ALPHABET: &[u8; 64] =
b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
let mut out = String::new();
for chunk in bytes.chunks(3) {
let mut block = [0u8; 3];
block[..chunk.len()].copy_from_slice(chunk);
let n = u32::from_be_bytes([0, block[0], block[1], block[2]]);
let digits = chunk.len() * 8 / 6 + 1;
for i in 0..4 {
if i < digits {
out.push(ALPHABET[((n >> (18 - i * 6)) & 63) as usize] as char);
} else {
out.push('=');
}
}
}
out
}
#[test]
fn rejects_a_non_numeric_workchain() {
assert!(matches!(
Address::parse("zz:3333333333333333333333333333333333333333333333333333333333333333"),
Err(Error::Address(_))
));
}
#[test]
fn rejects_a_short_account_id() {
assert!(matches!(Address::parse("0:3333"), Err(Error::Address(_))));
}
}