use serde::Deserialize;
use crate::codec::base64_decode;
use crate::{BlockIdExt, Error};
const DEFAULT_MAX_HEAD_AGE: u32 = 600;
#[derive(Debug, Clone)]
pub struct Config {
liteservers: Vec<LiteServer>,
init_block: Option<BlockIdExt>,
max_head_age: u32,
}
#[derive(Debug, Clone)]
pub(crate) struct LiteServer {
pub(crate) addr: String,
pub(crate) key: [u8; 32],
}
impl Config {
#[must_use]
#[expect(clippy::expect_used, reason = "a checked-in file, held by a test")]
pub fn mainnet() -> Config {
Config::from_json(include_str!("mainnet.config.json"))
.expect("the bundled mainnet config parses")
}
pub fn from_json(json: &str) -> Result<Config, Error> {
let raw: RawConfig =
serde_json::from_str(json).map_err(|e| Error::Config(e.to_string()))?;
if raw.liteservers.is_empty() {
return Err(Error::Config("config has no liteservers".to_string()));
}
let mut liteservers = Vec::with_capacity(raw.liteservers.len());
for server in raw.liteservers {
if server.id.key_type != "pub.ed25519" {
return Err(Error::Config(format!(
"unsupported liteserver key type `{}`",
server.id.key_type
)));
}
let key: [u8; 32] = base64_decode(&server.id.key)
.and_then(|bytes| bytes.try_into().ok())
.ok_or_else(|| {
Error::Config("liteserver key is not 32 base64 bytes".to_string())
})?;
let octets = (server.ip as u32).to_be_bytes();
let addr = format!(
"{}.{}.{}.{}:{}",
octets[0], octets[1], octets[2], octets[3], server.port
);
liteservers.push(LiteServer { addr, key });
}
let init_block = match raw.validator.and_then(|validator| validator.init_block) {
Some(block) => Some(BlockIdExt::new(
block.workchain,
block.shard as u64,
block.seqno,
hash(&block.root_hash, "init block root hash")?,
hash(&block.file_hash, "init block file hash")?,
)),
None => None,
};
Ok(Config {
liteservers,
init_block,
max_head_age: DEFAULT_MAX_HEAD_AGE,
})
}
#[must_use]
pub fn init_block(&self) -> Option<&BlockIdExt> {
self.init_block.as_ref()
}
#[must_use]
pub fn with_max_head_age(mut self, seconds: u32) -> Config {
self.max_head_age = seconds;
self
}
#[must_use]
pub fn max_head_age(&self) -> u32 {
self.max_head_age
}
pub(crate) fn liteservers(&self) -> &[LiteServer] {
&self.liteservers
}
}
fn hash(encoded: &str, what: &'static str) -> Result<[u8; 32], Error> {
base64_decode(encoded)
.and_then(|bytes| bytes.try_into().ok())
.ok_or_else(|| Error::Config(format!("{what} is not 32 base64 bytes")))
}
#[derive(Deserialize)]
struct RawConfig {
liteservers: Vec<RawLiteServer>,
validator: Option<RawValidator>,
}
#[derive(Deserialize)]
struct RawValidator {
init_block: Option<RawBlockId>,
}
#[derive(Deserialize)]
struct RawBlockId {
workchain: i32,
shard: i64,
seqno: u32,
root_hash: String,
file_hash: String,
}
#[derive(Deserialize)]
struct RawLiteServer {
ip: i64,
port: u16,
id: RawId,
}
#[derive(Deserialize)]
struct RawId {
#[serde(rename = "@type")]
key_type: String,
key: String,
}
#[cfg(test)]
mod tests {
use super::*;
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
const KEY: &str = "n4VDnSCUuSpjnCyUk9e3QOOd6o0ItSWYbTnW3Wnn8wk=";
#[test]
fn mainnet_parses_and_leads_with_the_proven_server() {
let config = Config::mainnet();
assert!(!config.liteservers().is_empty());
assert_eq!(config.liteservers()[0].addr, "5.9.10.47:19949");
}
#[test]
fn mainnet_names_the_block_a_first_sync_starts_from() {
let config = Config::mainnet();
let init = config
.init_block()
.expect("the snapshot names an init block");
assert_eq!(init.workchain, -1);
assert_eq!(init.shard, 0x8000_0000_0000_0000);
assert_eq!(init.seqno, 46_894_135);
assert_eq!(
hex(&init.root_hash),
"3048e69a12cf946ebc99b4cf9ca61c3ff4b3fcc88c4015763ac01204ecc1bf9f"
);
assert_eq!(
hex(&init.file_hash),
"bbdac0b4543e9141449ceb37c3c63ba6e9cc4e2c904d77f56d17e44acf1d1bed"
);
}
#[test]
fn the_freshness_bound_has_a_default_and_can_be_set() {
let config = Config::mainnet();
assert_eq!(config.max_head_age(), DEFAULT_MAX_HEAD_AGE);
assert_eq!(config.with_max_head_age(30).max_head_age(), 30);
}
#[test]
fn from_json_reads_an_init_block() {
let json = format!(
r#"{{"liteservers":[{{"ip":84478511,"port":19949,"id":{{"@type":"pub.ed25519","key":"{KEY}"}}}}],
"validator":{{"init_block":{{"workchain":-1,"shard":-9223372036854775808,"seqno":7,
"root_hash":"{KEY}","file_hash":"{KEY}"}}}}}}"#
);
let config = Config::from_json(&json).unwrap();
let init = config.init_block().expect("an init block");
assert_eq!(init.workchain, -1);
assert_eq!(init.shard, 0x8000_0000_0000_0000);
assert_eq!(init.seqno, 7);
}
#[test]
fn from_json_accepts_a_config_with_no_init_block() {
let json = format!(
r#"{{"liteservers":[{{"ip":84478511,"port":19949,"id":{{"@type":"pub.ed25519","key":"{KEY}"}}}}]}}"#
);
assert!(Config::from_json(&json).unwrap().init_block().is_none());
}
#[test]
fn from_json_rejects_an_init_block_hash_that_is_not_32_bytes() {
let json = format!(
r#"{{"liteservers":[{{"ip":84478511,"port":19949,"id":{{"@type":"pub.ed25519","key":"{KEY}"}}}}],
"validator":{{"init_block":{{"workchain":-1,"shard":-9223372036854775808,"seqno":7,
"root_hash":"AAAA","file_hash":"{KEY}"}}}}}}"#
);
assert!(matches!(Config::from_json(&json), Err(Error::Config(_))));
}
#[test]
fn from_json_reads_a_liteserver() {
let json = format!(
r#"{{"liteservers":[{{"ip":84478511,"port":19949,"id":{{"@type":"pub.ed25519","key":"{KEY}"}}}}]}}"#
);
let config = Config::from_json(&json).unwrap();
assert_eq!(config.liteservers().len(), 1);
assert_eq!(config.liteservers()[0].addr, "5.9.10.47:19949");
assert_eq!(
hex(&config.liteservers()[0].key),
"9f85439d2094b92a639c2c9493d7b740e39dea8d08b525986d39d6dd69e7f309"
);
}
#[test]
fn from_json_decodes_a_negative_ip() {
let json = format!(
r#"{{"liteservers":[{{"ip":-1062731775,"port":1,"id":{{"@type":"pub.ed25519","key":"{KEY}"}}}}]}}"#
);
let config = Config::from_json(&json).unwrap();
assert_eq!(config.liteservers()[0].addr, "192.168.0.1:1");
}
#[test]
fn from_json_ignores_the_other_config_sections() {
let json = format!(
r#"{{"@type":"config.global","dht":{{"k":1}},"liteservers":[{{"ip":84478511,"port":19949,"extra":true,"id":{{"@type":"pub.ed25519","key":"{KEY}"}}}}],"validator":{{"zero_state":{{"workchain":-1}}}}}}"#
);
let config = Config::from_json(&json).unwrap();
assert_eq!(config.liteservers().len(), 1);
assert_eq!(config.liteservers()[0].addr, "5.9.10.47:19949");
}
#[test]
fn from_json_rejects_an_unsupported_key_type() {
let json = format!(
r#"{{"liteservers":[{{"ip":84478511,"port":19949,"id":{{"@type":"pub.unknown","key":"{KEY}"}}}}]}}"#
);
assert!(matches!(Config::from_json(&json), Err(Error::Config(_))));
}
#[test]
fn from_json_rejects_malformed_json() {
assert!(matches!(
Config::from_json("{not json"),
Err(Error::Config(_))
));
}
#[test]
fn from_json_rejects_an_empty_liteserver_list() {
assert!(matches!(
Config::from_json(r#"{"liteservers":[]}"#),
Err(Error::Config(_))
));
}
}