GRIN/nym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ipr version revert on develop (#6772)

Browse Source
This commit is contained in:
Simon Wicky
2026-05-15 09:42:30 +02:00
committed by GitHub
parent b501ddd534
commit 87c236a927
13 changed files with 55 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+2 -2
View File
@@ -9635,9 +9635,9 @@ checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
[[package]]
name = "prefix-trie"
version = "0.8.3"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90f561214012d3fc240a1f9c817cc4d57f5310910d066069c1b093f766bb5966"
checksum = "4cf6e3177f0684016a5c209b00882e15f8bdd3f3bb48f0491df10cd102d0c6e7"
dependencies = [
"either",
"ipnet",
common/ip-packet-requests/src/lib.rs
-15
View File
@@ -20,21 +20,6 @@ pub const MAX_NON_STREAM_VERSION: u8 = v8::VERSION;
/// mixnet sends, matching the node-side enforcement in `ip-packet-router`.
pub const SPHINX_STREAM_VERSION_THRESHOLD: u8 = v9::VERSION;
#[cfg(test)]
mod tests {
use super::*;
const _: () = {
assert!(SPHINX_STREAM_VERSION_THRESHOLD > MAX_NON_STREAM_VERSION);
};
#[test]
fn stream_transport_threshold_is_consistent() {
assert_eq!(MAX_NON_STREAM_VERSION, 8);
assert_eq!(SPHINX_STREAM_VERSION_THRESHOLD, 9);
}
}
// version 3: initial version
// version 4: IPv6 support
// version 5: Add severity level to info response
nym-gateway-probe/src/common/helpers.rs
+2 -6
View File
@@ -1,10 +1,9 @@
// Copyright 2026 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0
use nym_ip_packet_client::current::response::{
use nym_ip_packet_requests::v8::response::{
ControlResponse, DataResponse, InfoLevel, IpPacketResponse, IpPacketResponseData,
};
use nym_ip_packet_client::lp_stream;
use nym_sdk::{
DebugConfig, NymApiTopologyProvider, NymApiTopologyProviderConfig, NymNetworkDetails,
TopologyProvider, mixnet::ReconstructedMessage,
@@ -33,10 +32,7 @@ pub fn mixnet_debug_config(
}
pub fn unpack_data_response(reconstructed_message: &ReconstructedMessage) -> Option<DataResponse> {
let payload =
lp_stream::maybe_unwrap_lp_stream_payload_from_reconstructed(reconstructed_message);
match IpPacketResponse::from_bytes(payload) {
match IpPacketResponse::from_reconstructed_message(reconstructed_message) {
Ok(response) => match response.data {
IpPacketResponseData::Data(data_response) => Some(data_response),
IpPacketResponseData::Control(control) => match *control {
nym-gateway-probe/src/common/icmp.rs
+5 -24
View File
@@ -9,7 +9,7 @@ use nym_connection_monitor::{
wrap_icmp_in_ipv6,
},
};
use nym_ip_packet_requests::{IpPair, codec::MultiIpPacketCodec};
use nym_ip_packet_requests::{IpPair, codec::MultiIpPacketCodec, v8::request::IpPacketRequest};
use nym_sdk::mixnet::{
InputMessage, MixnetClient, MixnetMessageSender, Recipient, TransmissionLane,
};
@@ -25,7 +25,6 @@ pub async fn send_ping_v4(
sequence_number: u16,
destination: Ipv4Addr,
exit_router_address: Recipient,
stream_id: u64,
) -> anyhow::Result<()> {
let icmp_identifier = icmp_identifier();
let icmp_echo_request = create_icmpv4_echo_request(sequence_number, icmp_identifier)?;
@@ -36,12 +35,7 @@ pub async fn send_ping_v4(
MultiIpPacketCodec::bundle_one_packet(ipv4_packet.packet().to_vec().into());
// Wrap into a mixnet input message addressed to the IPR
let mixnet_message = create_input_message(
exit_router_address,
bundled_packet,
stream_id,
sequence_number,
)?;
let mixnet_message = create_input_message(exit_router_address, bundled_packet)?;
mixnet_client.send(mixnet_message).await?;
Ok(())
@@ -53,7 +47,6 @@ pub async fn send_ping_v6(
sequence_number: u16,
destination: Ipv6Addr,
exit_router_address: Recipient,
stream_id: u64,
) -> anyhow::Result<()> {
let icmp_identifier = icmp_identifier();
let icmp_echo_request = create_icmpv6_echo_request(
@@ -69,12 +62,7 @@ pub async fn send_ping_v6(
MultiIpPacketCodec::bundle_one_packet(ipv6_packet.packet().to_vec().into());
// Wrap into a mixnet input message addressed to the IPR
let mixnet_message = create_input_message(
exit_router_address,
bundled_packet,
stream_id,
sequence_number,
)?;
let mixnet_message = create_input_message(exit_router_address, bundled_packet)?;
// Send across the mixnet
mixnet_client.send(mixnet_message).await?;
@@ -84,22 +72,15 @@ pub async fn send_ping_v6(
fn create_input_message(
recipient: impl Into<Recipient>,
bundled_packets: Bytes,
stream_id: u64,
sequence_number: u16,
) -> anyhow::Result<InputMessage> {
let packet = nym_ip_packet_client::current::new_data_request(bundled_packets).to_bytes()?;
let framed_packet = nym_ip_packet_client::lp_stream::encode_stream_frame(
stream_id,
sequence_number as u32,
packet,
);
let packet = IpPacketRequest::new_data_request(bundled_packets).to_bytes()?;
let lane = TransmissionLane::General;
let packet_type = None;
let surbs = 0;
Ok(InputMessage::new_anonymous(
recipient.into(),
framed_packet,
packet,
surbs,
lane,
packet_type,
nym-gateway-probe/src/common/probe_tests.rs
+5 -18
View File
@@ -256,8 +256,8 @@ pub async fn do_ping(
let (maybe_ip_pair, mut mixnet_client) =
connect_exit(mixnet_client, exit_router_address).await;
match maybe_ip_pair {
Some((ip_pair, stream_id)) => (
do_ping_exit(&mut mixnet_client, ip_pair, stream_id, exit_router_address).await,
Some(ip_pair) => (
do_ping_exit(&mut mixnet_client, ip_pair, exit_router_address).await,
mixnet_client,
),
None => (Ok(Some(Exit::fail_to_connect())), mixnet_client),
@@ -304,7 +304,7 @@ async fn do_ping_entry(
async fn connect_exit(
mixnet_client: MixnetClient,
exit_router_address: Recipient,
) -> (Option<(IpPair, u64)>, MixnetClient) {
) -> (Option<IpPair>, MixnetClient) {
// Step 2: connect to the exit gateway
info!(
"Connecting to exit gateway: {}",
@@ -315,19 +315,12 @@ async fn connect_exit(
let mut ipr_client = IprClientConnect::new(mixnet_client, cancel_token);
let maybe_ip_pair = ipr_client.connect(exit_router_address).await;
let stream_id = ipr_client.stream_id();
let mixnet_client = ipr_client.into_mixnet_client();
if let Ok(our_ips) = maybe_ip_pair {
info!("Successfully connected to exit gateway");
info!("Using mixnet VPN IP addresses: {our_ips}");
let Some(stream_id) = stream_id else {
tracing::warn!(
"No active IPR stream id set after connect; cannot run IPR data-plane tests"
);
return (None, mixnet_client);
};
(Some((our_ips, stream_id)), mixnet_client)
(Some(our_ips), mixnet_client)
} else {
(None, mixnet_client)
}
@@ -336,11 +329,10 @@ async fn connect_exit(
pub async fn do_ping_exit(
mixnet_client: &mut MixnetClient,
our_ips: IpPair,
stream_id: u64,
exit_router_address: Recipient,
) -> anyhow::Result<Option<Exit>> {
// Step 3: perform ICMP connectivity checks for the exit gateway
send_icmp_pings(mixnet_client, our_ips, exit_router_address, stream_id).await?;
send_icmp_pings(mixnet_client, our_ips, exit_router_address).await?;
listen_for_icmp_ping_replies(mixnet_client, our_ips).await
}
@@ -348,7 +340,6 @@ async fn send_icmp_pings(
mixnet_client: &MixnetClient,
our_ips: IpPair,
exit_router_address: Recipient,
stream_id: u64,
) -> anyhow::Result<()> {
// ipv4 addresses for testing
let ipr_tun_ip_v4 = NYM_TUN_DEVICE_ADDRESS_V4;
@@ -370,7 +361,6 @@ async fn send_icmp_pings(
ii,
ipr_tun_ip_v4,
exit_router_address,
stream_id,
)
.await?;
icmp::send_ping_v4(
@@ -379,7 +369,6 @@ async fn send_icmp_pings(
ii,
external_ip_v4,
exit_router_address,
stream_id,
)
.await?;
}
@@ -392,7 +381,6 @@ async fn send_icmp_pings(
ii,
ipr_tun_ip_v6,
exit_router_address,
stream_id,
)
.await?;
icmp::send_ping_v6(
@@ -401,7 +389,6 @@ async fn send_icmp_pings(
ii,
external_ip_v6,
exit_router_address,
stream_id,
)
.await?;
}
nym-ip-packet-client/src/connect.rs
+16 -65
View File
@@ -14,7 +14,7 @@ use tracing::{debug, error};
use nym_ip_packet_requests::response_helpers::{self, IprResponseError};
use crate::{
current::{self, response::IpPacketResponse},
current::{request::IpPacketRequest, response::IpPacketResponse},
error::{Error, Result},
helpers::check_ipr_message_version,
};
@@ -24,12 +24,8 @@ const IPR_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
#[derive(Clone, Debug, PartialEq, Eq)]
enum ConnectionState {
Disconnected,
Connecting {
stream_id: u64,
},
Connected {
stream_id: u64,
},
Connecting,
Connected,
#[allow(unused)]
Disconnecting,
}
@@ -55,27 +51,17 @@ impl IprClientConnect {
self.mixnet_client
}
pub fn stream_id(&self) -> Option<u64> {
match self.connected {
ConnectionState::Connecting { stream_id }
| ConnectionState::Connected { stream_id } => Some(stream_id),
ConnectionState::Disconnected | ConnectionState::Disconnecting => None,
}
}
pub async fn connect(&mut self, ip_packet_router_address: Recipient) -> Result<IpPair> {
if self.connected != ConnectionState::Disconnected {
return Err(Error::AlreadyConnected);
}
tracing::info!("Connecting to exit gateway");
self.connected = ConnectionState::Connecting;
match self.connect_inner(ip_packet_router_address).await {
Ok(ips) => {
debug!("Successfully connected to the ip-packet-router");
let Some(stream_id) = self.stream_id() else {
return Err(Error::UnexpectedConnectResponse);
};
self.connected = ConnectionState::Connected { stream_id };
self.connected = ConnectionState::Connected;
Ok(ips)
}
Err(err) => {
@@ -88,37 +74,21 @@ impl IprClientConnect {
async fn connect_inner(&mut self, ip_packet_router_address: Recipient) -> Result<IpPair> {
let request_id = self.send_connect_request(ip_packet_router_address).await?;
self.connected = ConnectionState::Connecting {
stream_id: request_id,
};
debug!("Waiting for reply...");
self.listen_for_connect_response(request_id).await
}
async fn send_connect_request(&mut self, ip_packet_router_address: Recipient) -> Result<u64> {
let (request, request_id) = current::new_connect_request(None);
tracing::info!(
request_id = request_id,
protocol_version = request.protocol.version,
current_version = crate::current::VERSION,
"Sending IPR connect request"
);
if let Ok(bytes) = request.to_bytes() {
let prefix = bytes.get(0..2).unwrap_or(&bytes);
let prefix_hex = format!("{:02x?}", prefix);
tracing::info!(request_id = request_id, prefix = %prefix_hex, "IPR connect bytes prefix");
}
async fn send_connect_request(&self, ip_packet_router_address: Recipient) -> Result<u64> {
let (request, request_id) = IpPacketRequest::new_connect_request(None);
// We use 20 surbs for the connect request because typically the IPR is configured to have
// a min threshold of 10 surbs that it reserves for itself to request additional surbs.
let surbs = 20;
let request_bytes = request.to_bytes()?;
let framed_bytes = maybe_wrap_stream_frame(request_id, 0, request_bytes);
self.mixnet_client
.send(create_input_message(
ip_packet_router_address,
framed_bytes,
request,
surbs,
)?)
.await
@@ -159,19 +129,13 @@ impl IprClientConnect {
for msg in msgs {
// Confirm that the version is correct
if let Err(err) = check_ipr_message_version(&msg) {
let raw: &[u8] = msg.message.as_ref();
tracing::warn!(
first_byte = raw.first().copied(),
expected = crate::current::VERSION,
len = raw.len(),
"Mixnet message version mismatch: {err}"
);
tracing::info!("Mixnet message version mismatch: {err}");
continue;
}
// Then we deserialize the message
tracing::debug!("IprClient: got message while waiting for connect response");
let Ok(response) = ipr_response_from_reconstructed_message(&msg) else {
let Ok(response) = IpPacketResponse::from_reconstructed_message(&msg) else {
// This is ok, it's likely just one of our self-pings
tracing::debug!("Failed to deserialize mixnet message");
continue;
@@ -196,27 +160,14 @@ impl IprClientConnect {
}
}
fn maybe_wrap_stream_frame(stream_id: u64, sequence_num: u32, payload: Vec<u8>) -> Vec<u8> {
if !crate::lp_stream::current_requires_sphinx_stream_transport() {
return payload;
}
crate::lp_stream::encode_stream_frame(stream_id, sequence_num, payload)
}
fn ipr_response_from_reconstructed_message(
msg: &nym_sdk::mixnet::ReconstructedMessage,
) -> std::result::Result<IpPacketResponse, bincode::Error> {
let warn_on_unexpected = crate::lp_stream::current_requires_sphinx_stream_transport();
let payload =
crate::lp_stream::maybe_unwrap_lp_stream_payload(&msg.message, warn_on_unexpected);
IpPacketResponse::from_bytes(payload)
}
fn create_input_message(recipient: Recipient, bytes: Vec<u8>, surbs: u32) -> Result<InputMessage> {
fn create_input_message(
recipient: Recipient,
request: IpPacketRequest,
surbs: u32,
) -> Result<InputMessage> {
Ok(InputMessage::new_anonymous(
recipient,
bytes,
request.to_bytes()?,
surbs,
TransmissionLane::General,
None,
nym-ip-packet-client/src/helpers.rs
+14 -12
View File
@@ -7,16 +7,18 @@ use nym_sdk::mixnet::ReconstructedMessage;
use crate::{current::VERSION as CURRENT_VERSION, error::Result};
pub(crate) fn check_ipr_message_version(message: &ReconstructedMessage) -> Result<()> {
let payload = crate::lp_stream::maybe_unwrap_lp_stream_payload_from_reconstructed(message);
nym_ip_packet_requests::response_helpers::check_ipr_message_version(payload, CURRENT_VERSION)
.map_err(|e| match e {
IprResponseError::NoVersionByte => crate::Error::NoVersionInMessage,
IprResponseError::VersionMismatch { expected, received } if received < expected => {
crate::Error::ReceivedResponseWithOldVersion { expected, received }
}
IprResponseError::VersionMismatch { expected, received } => {
crate::Error::ReceivedResponseWithNewVersion { expected, received }
}
_ => crate::Error::NoVersionInMessage,
})
nym_ip_packet_requests::response_helpers::check_ipr_message_version(
&message.message,
CURRENT_VERSION,
)
.map_err(|e| match e {
IprResponseError::NoVersionByte => crate::Error::NoVersionInMessage,
IprResponseError::VersionMismatch { expected, received } if received < expected => {
crate::Error::ReceivedResponseWithOldVersion { expected, received }
}
IprResponseError::VersionMismatch { expected, received } => {
crate::Error::ReceivedResponseWithNewVersion { expected, received }
}
_ => crate::Error::NoVersionInMessage,
})
}
nym-ip-packet-client/src/lib.rs
+1 -2
View File
@@ -5,11 +5,10 @@ mod connect;
mod error;
mod helpers;
mod listener;
pub mod lp_stream;
pub use connect::IprClientConnect;
pub use error::Error;
pub use listener::{IprListener, MixnetMessageOutcome};
// Re-export the currently used version
pub use nym_ip_packet_requests::v9 as current;
pub use nym_ip_packet_requests::v8 as current;
nym-ip-packet-client/src/lp_stream.rs
-100
View File
@@ -1,100 +0,0 @@
use bytes::BytesMut;
use nym_ip_packet_requests::SPHINX_STREAM_VERSION_THRESHOLD;
use nym_lp::packet::frame::{
LpFrame, LpFrameHeader, LpFrameKind, SphinxStreamFrameAttributes, SphinxStreamMsgType,
};
use nym_sdk::mixnet::ReconstructedMessage;
use tracing::warn;
/// Whether the "current" IPR client is operating at a version where the node expects
/// non-stream mixnet IPR messages to be LP Stream framed (see `SPHINX_STREAM_VERSION_THRESHOLD`).
pub(crate) fn current_requires_sphinx_stream_transport() -> bool {
crate::current::VERSION >= SPHINX_STREAM_VERSION_THRESHOLD
}
pub fn maybe_unwrap_lp_stream_payload(data: &[u8], warn_on_unexpected: bool) -> &[u8] {
if data.len() < LpFrameHeader::SIZE {
if warn_on_unexpected {
warn!(
len = data.len(),
header_size = LpFrameHeader::SIZE,
"expected LP SphinxStream frame for IPR payload, but message is shorter than LP header; treating as raw payload"
);
}
return data;
}
let Ok(header) = LpFrameHeader::parse(data) else {
if warn_on_unexpected {
warn!(
"expected LP SphinxStream frame for IPR payload, but failed to parse LP header; treating as raw payload"
);
}
return data;
};
if header.kind == LpFrameKind::SphinxStream {
&data[LpFrameHeader::SIZE..]
} else {
if warn_on_unexpected {
warn!(
kind = ?header.kind,
"expected LP SphinxStream frame for IPR payload, but got different LP frame kind; treating as raw payload"
);
}
data
}
}
pub fn maybe_unwrap_lp_stream_payload_from_reconstructed(message: &ReconstructedMessage) -> &[u8] {
maybe_unwrap_lp_stream_payload(&message.message, false)
}
pub fn encode_stream_frame(stream_id: u64, sequence_num: u32, payload: Vec<u8>) -> Vec<u8> {
let attrs = SphinxStreamFrameAttributes {
stream_id,
msg_type: SphinxStreamMsgType::Data,
sequence_num,
};
let frame = LpFrame::new_stream(attrs, payload);
let mut buf = BytesMut::with_capacity(LpFrameHeader::SIZE + frame.content.len());
frame.encode(&mut buf);
buf.to_vec()
}
#[cfg(test)]
mod tests {
use super::*;
use nym_lp::packet::frame::SphinxStreamFrameAttributes;
#[test]
fn stream_frame_roundtrip_unwraps_payload() {
let stream_id = 0x0123_4567_89ab_cdef;
let seq = 42u32;
let payload = b"hello-ipr".to_vec();
let framed = encode_stream_frame(stream_id, seq, payload.clone());
let header = LpFrameHeader::parse(&framed).expect("valid lp header");
assert_eq!(header.kind, LpFrameKind::SphinxStream);
let attrs =
SphinxStreamFrameAttributes::parse(&header.frame_attributes).expect("valid attrs");
assert_eq!(attrs.stream_id, stream_id);
assert_eq!(attrs.sequence_num, seq);
assert_eq!(attrs.msg_type, SphinxStreamMsgType::Data);
let unwrapped = maybe_unwrap_lp_stream_payload(&framed, false);
assert_eq!(unwrapped, payload.as_slice());
}
#[test]
fn unwrap_noops_on_non_stream_or_malformed_data() {
let raw = b"\x09\x00\x01\x02\x03";
assert_eq!(maybe_unwrap_lp_stream_payload(raw, false), raw);
// malformed header: not enough bytes for LP header
let short = b"\x00\x01";
assert_eq!(maybe_unwrap_lp_stream_payload(short, false), short);
}
}
sdk/rust/nym-sdk/src/ipr_wrapper/ip_mix_stream.rs
+6 -4
View File
@@ -9,9 +9,11 @@ use crate::ip_packet_client::{
use crate::mixnet::{MixnetClient, MixnetStream, Recipient};
use crate::Error;
use bytes::Bytes;
use current_ipr::response::IpPacketResponse;
use nym_ip_packet_requests::response_helpers;
use nym_ip_packet_requests::{v9 as current_ipr, IpPair};
use nym_ip_packet_requests::{
v9::{self, response::IpPacketResponse},
IpPair,
};
use nym_network_defaults::NymNetworkDetails;
use std::time::Duration;
use tokio::io::AsyncWriteExt;
@@ -105,7 +107,7 @@ impl IpMixStream {
}
async fn connect_tunnel(stream: &mut MixnetStream) -> Result<IpPair, Error> {
let (request, request_id) = current_ipr::new_connect_request(None);
let (request, request_id) = v9::new_connect_request(None);
debug!("Sending connect request with ID: {}", request_id);
let request_bytes = request.to_bytes()?;
@@ -144,7 +146,7 @@ impl IpMixStream {
/// Send an IP packet through the tunnel.
pub async fn send_ip_packet(&mut self, packet: &[u8]) -> Result<(), Error> {
self.check_connected()?;
let request = current_ipr::new_data_request(packet.to_vec().into());
let request = v9::new_data_request(packet.to_vec().into());
let request_bytes = request.to_bytes()?;
self.stream
.write_all(&request_bytes)
service-providers/ip-packet-router/src/clients/connected_client_handler.rs
+1 -4
View File
@@ -218,10 +218,7 @@ fn create_ip_packet_response(
ClientVersion::V6 => IpPacketResponseV6::new_ip_packet(packets).to_bytes(),
ClientVersion::V7 => IpPacketResponseV7::new_ip_packet(packets).to_bytes(),
ClientVersion::V8 => IpPacketResponseV8::new_ip_packet(packets).to_bytes(),
ClientVersion::V9 => {
let resp = v9::new_ip_packet_response(packets);
resp.to_bytes()
}
ClientVersion::V9 => v9::new_ip_packet_response(packets).to_bytes(),
}
}
service-providers/ip-packet-router/src/messages/request.rs
+2 -3
View File
@@ -10,7 +10,6 @@ use nym_ip_packet_requests::{
IpPair, v6::request::IpPacketRequest as IpPacketRequestV6,
v7::request::IpPacketRequest as IpPacketRequestV7,
v8::request::IpPacketRequest as IpPacketRequestV8,
v9::request::IpPacketRequest as IpPacketRequestV9,
};
use nym_sdk::mixnet::ReconstructedMessage;
use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
@@ -132,14 +131,14 @@ impl TryFrom<&ReconstructedMessage> for IpPacketRequest {
Ok(IpPacketRequest::from((request_v8, sender_tag)))
}
9 => {
let request_v9 = IpPacketRequestV9::from_reconstructed_message(reconstructed)
let request_v8 = IpPacketRequestV8::from_reconstructed_message(reconstructed)
.map_err(
|source| IpPacketRouterError::FailedToDeserializeTaggedPacket { source },
)?;
let sender_tag = reconstructed
.sender_tag
.ok_or(IpPacketRouterError::MissingSenderTag)?;
Ok(v9::convert(request_v9, sender_tag))
Ok(v9::convert(request_v8, sender_tag))
}
_ => {
log::info!("Received packet with invalid version: v{request_version}");
service-providers/ip-packet-router/src/messages/response.rs
+1 -5
View File
@@ -130,11 +130,7 @@ impl VersionedResponse {
ClientVersion::V6 => IpPacketResponseV6::try_from(self)?.to_bytes(),
ClientVersion::V7 => IpPacketResponseV7::try_from(self)?.to_bytes(),
ClientVersion::V8 => IpPacketResponseV8::try_from(self)?.to_bytes(),
ClientVersion::V9 => {
let mut resp = IpPacketResponseV8::try_from(self)?;
resp.version = nym_ip_packet_requests::v9::VERSION;
resp.to_bytes()
}
ClientVersion::V9 => IpPacketResponseV8::try_from(self)?.to_bytes(),
}
.map_err(|err| IpPacketRouterError::FailedToSerializeResponsePacket { source: err })
}