19957094785

Committed 05 Dec 2025 08:23AM UTC coverage: 86.918% (+8.5%) from 78.463%

Build # 19957094785

Build Type

Pull #837

github

Committed by

web-flow

Commit Message

Merge dec08367a into 2f840d387

Pull Request Pull Request #837: Split TransactionHintsBag hints properly

Run Details

44 of 53 new or added lines in 13 files covered. (83.02%)

1621 existing lines in 221 files now uncovered.

27453 of 31585 relevant lines covered (86.92%)

253204.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.11

/ergo-rest/src/peer_info.rs

use ergo_chain_types::ConnectionDirection;
use ergo_chain_types::PeerAddr;
use serde::{de::Error, Deserialize, Deserializer, Serialize};

#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
#[repr(C)]
/// Peer info returned by node REST API
pub struct PeerInfo {
    /// Peer address
    #[serde(
        rename = "address",
        deserialize_with = "parse_peer_addr_with_leading_slash"
    )]
    pub addr: PeerAddr,
    /// Last message
    #[serde(rename = "lastMessage")]
    pub last_message: u64,
    /// Timestamp of the last handshake
    #[serde(rename = "lastHandshake")]
    pub last_handshake: u64, // TODO: any more precise type?
    /// Node name
    pub name: String,
    /// Type of connection (Incoming/Outgoing) established to this peer if any
    #[serde(rename = "connectionType")]
    pub conn_type: Option<ConnectionDirection>,
}

/// The `PeerAddr` reported by ergo nodes at the `peers/all` endpoint begin with a leading '/'.
/// This custom deserialization function simply removes the leading character then uses the
/// serde-generated function to parse.
fn parse_peer_addr_with_leading_slash<'de, D>(deserializer: D) -> Result<PeerAddr, D::Error>
where
    D: Deserializer<'de>,
{
    let s: &str = Deserialize::deserialize(deserializer)?;

    let s = if s.starts_with('/') {
        let mut chars = s.chars();
        chars.next();
        chars.as_str()
    } else {
        s
    };
    match s.parse().map_err(D::Error::custom) {
        Ok(peer_addr) => Ok(peer_addr),
        Err(_) => {
            // try to fix an invalid IP v6 address encoding on node
            // the format should be `[ipv6]:port`, but pre-JDK14 node returns `ipv6:port`
            // see https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8225499
            //dbg!(&s);
            let parts: Vec<&str> = s.rsplit(':').collect();
            if parts.len() == 2 {
                // not an IP v6 address
                return Err(D::Error::custom(format!(
                    "expected invalid IP v6(without brackets) address, got: {}",
                    s
                )));
            }
            #[allow(clippy::unwrap_used)]
            let port = parts.first().cloned().unwrap();
            let host: String = parts
                .into_iter()
                .skip(1)
                .rev()
                .collect::<Vec<&str>>()
                .join(":");
            // put host inside brackets to make it a valid IP v6 address
            let str = format!("[{}]:{}", host, port);
            str.parse().map_err(D::Error::custom)
        }
    }
}

#[cfg(test)]
#[cfg(feature = "json")]
#[allow(clippy::unwrap_used)]
mod tests {
    use super::*;
    #[test]
    fn test_parse_peer_info() {
        let json = "{\n    \"address\" : \"/62.106.112.158:9030\",\n    \"lastMessage\" : 0,\n    \"lastHandshake\" : 0,\n    \"name\" : \"ergo-mainnet-4.0.12\",\n    \"connectionType\" : null\n  }";
        let _: PeerInfo = serde_json::from_str(json).unwrap();
    }

    #[test]
    fn test_parse_peer_info_ipv6_pre_jkd14() {
        let json = "{\n    \"address\" : \"/2a0d:6fc0:7cb:be00:50be:7d74:7a00:aa3e:9030\",\n    \"lastMessage\" : 0,\n    \"lastHandshake\" : 0,\n    \"name\" : \"ergo-mainnet-4.0.12\",\n    \"connectionType\" : null\n  }";
        let _: PeerInfo = serde_json::from_str(json).unwrap();
    }
}

1	use ergo_chain_types::ConnectionDirection;
2	use ergo_chain_types::PeerAddr;
3	use serde::{de::Error, Deserialize, Deserializer, Serialize};
4
5	#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
6	#[repr(C)]
7	/// Peer info returned by node REST API
8	pub struct PeerInfo {
9	/// Peer address
10	#[serde(
11	rename = "address",
12	deserialize_with = "parse_peer_addr_with_leading_slash"
13	)]
14	pub addr: PeerAddr,
15	/// Last message
16	#[serde(rename = "lastMessage")]
17	pub last_message: u64,
18	/// Timestamp of the last handshake
19	#[serde(rename = "lastHandshake")]
20	pub last_handshake: u64, // TODO: any more precise type?
21	/// Node name
22	pub name: String,
23	/// Type of connection (Incoming/Outgoing) established to this peer if any
24	#[serde(rename = "connectionType")]
25	pub conn_type: Option<ConnectionDirection>,
26	}
27
28	/// The `PeerAddr` reported by ergo nodes at the `peers/all` endpoint begin with a leading '/'.
29	/// This custom deserialization function simply removes the leading character then uses the
30	/// serde-generated function to parse.
31	fn parse_peer_addr_with_leading_slash<'de, D>(deserializer: D) -> Result<PeerAddr, D::Error>	21,124✔
32	where	21,124✔
33	D: Deserializer<'de>,	21,124✔
34	{
35	let s: &str = Deserialize::deserialize(deserializer)?;	21,124✔
36
37	let s = if s.starts_with('/') {	21,124✔
38	let mut chars = s.chars();	21,124✔
39	chars.next();	21,124✔
40	chars.as_str()	21,124✔
41	} else {
42	s	×
43	};
44	match s.parse().map_err(D::Error::custom) {	21,124✔
45	Ok(peer_addr) => Ok(peer_addr),	21,021✔
46	Err(_) => {
47	// try to fix an invalid IP v6 address encoding on node
48	// the format should be `[ipv6]:port`, but pre-JDK14 node returns `ipv6:port`
49	// see https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8225499
50	//dbg!(&s);
51	let parts: Vec<&str> = s.rsplit(':').collect();	103✔
52	if parts.len() == 2 {	103✔
53	// not an IP v6 address
54	return Err(D::Error::custom(format!(	×
55	"expected invalid IP v6(without brackets) address, got: {}",	×
56	s	×
UNCOV 57	)));	×
58	}	103✔
59	#[allow(clippy::unwrap_used)]
60	let port = parts.first().cloned().unwrap();	103✔
61	let host: String = parts	103✔
62	.into_iter()	103✔
63	.skip(1)	103✔
64	.rev()	103✔
65	.collect::<Vec<&str>>()	103✔
66	.join(":");	103✔
67	// put host inside brackets to make it a valid IP v6 address
68	let str = format!("[{}]:{}", host, port);	103✔
69	str.parse().map_err(D::Error::custom)	103✔
70	}
71	}
72	}	21,124✔
73
74	#[cfg(test)]
75	#[cfg(feature = "json")]
76	#[allow(clippy::unwrap_used)]
77	mod tests {
78	use super::*;
79	#[test]
80	fn test_parse_peer_info() {	1✔
81	let json = "{\n \"address\" : \"/62.106.112.158:9030\",\n \"lastMessage\" : 0,\n \"lastHandshake\" : 0,\n \"name\" : \"ergo-mainnet-4.0.12\",\n \"connectionType\" : null\n }";	1✔
82	let _: PeerInfo = serde_json::from_str(json).unwrap();	1✔
83	}	1✔
84
85	#[test]
86	fn test_parse_peer_info_ipv6_pre_jkd14() {	1✔
87	let json = "{\n \"address\" : \"/2a0d:6fc0:7cb:be00:50be:7d74:7a00:aa3e:9030\",\n \"lastMessage\" : 0,\n \"lastHandshake\" : 0,\n \"name\" : \"ergo-mainnet-4.0.12\",\n \"connectionType\" : null\n }";	1✔
88	let _: PeerInfo = serde_json::from_str(json).unwrap();	1✔
89	}	1✔
90	}

ergoplatform / sigma-rust / 19957094785

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous