use super::{Account, Asset, Chain, Identifier, Payload, Slippage, Text};
use crate::{
domain::{Amount, ExactDecimal, Source, Timestamp},
error::Error,
wallets::Preparation,
};
use serde::{Deserialize, Deserializer, Serialize};
use std::collections::BTreeSet;
fn nonnegative(value: &ExactDecimal) -> bool {
!value.is_negative()
}
fn optional_nonnegative(value: Option<&ExactDecimal>) -> bool {
value.is_none_or(nonnegative)
}
fn amount_for(amount: Amount, token: &Token) -> bool {
amount.decimals() == Some(token.data().decimals)
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "LimitsFields")]
pub struct Limits {
routes: u16,
steps: u16,
costs: u16,
}
impl Limits {
pub fn new(routes: u16, steps: u16, costs: u16) -> Result<Self, Error> {
if !(1..=64).contains(&routes) || !(1..=256).contains(&steps) || !(1..=128).contains(&costs)
{
return Err(super::invalid_record());
}
Ok(Self {
routes,
steps,
costs,
})
}
#[must_use]
pub const fn routes(self) -> u16 {
self.routes
}
#[must_use]
pub const fn steps(self) -> u16 {
self.steps
}
#[must_use]
pub const fn costs(self) -> u16 {
self.costs
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct LimitsFields {
routes: u16,
steps: u16,
costs: u16,
}
impl TryFrom<LimitsFields> for Limits {
type Error = Error;
fn try_from(v: LimitsFields) -> Result<Self, Error> {
Self::new(v.routes, v.steps, v.costs)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RequestData {
pub from: Asset,
pub to: Asset,
pub amount: Amount,
pub from_account: Account,
pub to_account: Option<Account>,
pub slippage: Slippage,
pub allow_switch_chain: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RequestData", into = "RequestData")]
pub struct Request(RequestData);
impl Request {
pub fn new(data: RequestData) -> Result<Self, Error> {
if data.amount.raw().is_zero()
|| data.from_account.chain() != data.from.chain()
|| data
.to_account
.as_ref()
.is_some_and(|a| a.chain() != data.to.chain())
{
return Err(super::invalid_record());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &RequestData {
&self.0
}
}
impl TryFrom<RequestData> for Request {
type Error = Error;
fn try_from(v: RequestData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Request> for RequestData {
fn from(v: Request) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TokenData {
pub asset: Asset,
pub decimals: u8,
pub symbol: Text,
pub name: Option<Text>,
pub price_usd: Option<ExactDecimal>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TokenData", into = "TokenData")]
pub struct Token(TokenData);
impl Token {
pub fn new(data: TokenData) -> Result<Self, Error> {
if !optional_nonnegative(data.price_usd.as_ref()) {
return Err(super::invalid_record());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &TokenData {
&self.0
}
}
impl TryFrom<TokenData> for Token {
type Error = Error;
fn try_from(v: TokenData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Token> for TokenData {
fn from(v: Token) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ActionData {
pub from_token: Token,
pub to_token: Token,
pub from_amount: Amount,
pub from_account: Option<Account>,
pub to_account: Option<Account>,
pub slippage: Option<Slippage>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ActionData", into = "ActionData")]
pub struct Action(ActionData);
impl Action {
pub fn new(data: ActionData) -> Result<Self, Error> {
if !amount_for(data.from_amount, &data.from_token)
|| data
.from_account
.as_ref()
.is_some_and(|a| a.chain() != data.from_token.data().asset.chain())
|| data
.to_account
.as_ref()
.is_some_and(|a| a.chain() != data.to_token.data().asset.chain())
{
return Err(super::invalid_record());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &ActionData {
&self.0
}
#[must_use]
pub fn matches_request(&self, request: &Request) -> bool {
let r = request.data();
let a = &self.0;
a.from_token.data().asset == r.from
&& a.to_token.data().asset == r.to
&& a.from_amount.raw() == r.amount.raw()
&& r.amount
.decimals()
.is_none_or(|d| d == a.from_token.data().decimals)
&& a.from_account.as_ref().is_none_or(|v| v == &r.from_account)
&& r.to_account.as_ref().is_none_or(|expected| {
a.to_account
.as_ref()
.is_none_or(|actual| actual == expected)
})
&& a.slippage.as_ref().is_none_or(|s| s == &r.slippage)
}
pub(super) fn same_intent(&self, other: &Self) -> bool {
let a = &self.0;
let b = &other.0;
a.from_token.data().asset == b.from_token.data().asset
&& a.to_token.data().asset == b.to_token.data().asset
&& a.from_token.data().decimals == b.from_token.data().decimals
&& a.to_token.data().decimals == b.to_token.data().decimals
&& a.from_amount == b.from_amount
&& a.from_account == b.from_account
&& a.to_account == b.to_account
&& a.slippage == b.slippage
}
}
impl TryFrom<ActionData> for Action {
type Error = Error;
fn try_from(v: ActionData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Action> for ActionData {
fn from(v: Action) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FeeData {
pub name: Text,
pub description: Text,
pub token: Token,
pub amount: Amount,
pub amount_usd: ExactDecimal,
pub percentage: ExactDecimal,
pub included: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "FeeData", into = "FeeData")]
pub struct Fee(FeeData);
impl Fee {
pub fn new(data: FeeData) -> Result<Self, Error> {
if !amount_for(data.amount, &data.token)
|| !nonnegative(&data.amount_usd)
|| !nonnegative(&data.percentage)
{
return Err(super::invalid_record());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &FeeData {
&self.0
}
}
impl TryFrom<FeeData> for Fee {
type Error = Error;
fn try_from(v: FeeData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Fee> for FeeData {
fn from(v: Fee) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GasCostData {
pub kind: Identifier,
pub price: ExactDecimal,
pub estimate: Amount,
pub limit: Amount,
pub token: Token,
pub amount: Amount,
pub amount_usd: ExactDecimal,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "GasCostData", into = "GasCostData")]
pub struct GasCost(GasCostData);
impl GasCost {
pub fn new(data: GasCostData) -> Result<Self, Error> {
if data.estimate.decimals().is_some()
|| data.limit.decimals().is_some()
|| !amount_for(data.amount, &data.token)
|| !nonnegative(&data.price)
|| !nonnegative(&data.amount_usd)
{
return Err(super::invalid_record());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &GasCostData {
&self.0
}
}
impl TryFrom<GasCostData> for GasCost {
type Error = Error;
fn try_from(v: GasCostData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<GasCost> for GasCostData {
fn from(v: GasCost) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "kind",
content = "value",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum Expiry {
Unreported,
SourceReported(Timestamp),
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EstimateData {
pub tool: Identifier,
pub from_amount: Amount,
pub to_amount: Amount,
pub to_amount_min: Amount,
pub from_amount_usd: Option<ExactDecimal>,
pub to_amount_usd: Option<ExactDecimal>,
pub approval_account: Option<Account>,
pub fees: Option<Vec<Fee>>,
pub gas_costs: Option<Vec<GasCost>>,
pub execution_seconds: ExactDecimal,
pub skip_approval: Option<bool>,
pub expiry: Expiry,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "EstimateData", into = "EstimateData")]
pub struct Estimate(EstimateData);
impl Estimate {
pub fn new(data: EstimateData) -> Result<Self, Error> {
if data.to_amount_min.raw() > data.to_amount.raw()
|| data.to_amount.decimals() != data.to_amount_min.decimals()
|| !optional_nonnegative(data.from_amount_usd.as_ref())
|| !optional_nonnegative(data.to_amount_usd.as_ref())
|| !nonnegative(&data.execution_seconds)
|| data.fees.as_ref().is_some_and(|v| v.len() > 128)
|| data.gas_costs.as_ref().is_some_and(|v| v.len() > 128)
{
return Err(super::invalid_record());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &EstimateData {
&self.0
}
}
impl TryFrom<EstimateData> for Estimate {
type Error = Error;
fn try_from(v: EstimateData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Estimate> for EstimateData {
fn from(v: Estimate) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StepKind {
Lifi,
Swap,
Cross,
Protocol,
Custom,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StepData {
pub id: Identifier,
pub kind: StepKind,
pub tool: Identifier,
pub action: Action,
pub estimate: Option<Estimate>,
pub included_steps: Vec<Step>,
pub payload: Option<Payload>,
pub transfer_id: Option<super::TransferId>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StepData", into = "StepData")]
pub struct Step(StepData);
impl Step {
pub fn new(data: StepData) -> Result<Self, Error> {
let v = Self(data);
let mut ids = BTreeSet::new();
v.validate_tree(0, &mut ids)?;
Ok(v)
}
fn validate_tree(&self, depth: usize, ids: &mut BTreeSet<Identifier>) -> Result<(), Error> {
let d = &self.0;
let a = d.action.data();
if depth > 8 || !ids.insert(d.id.clone()) || ids.len() > 256 {
return Err(super::invalid_record());
}
if let Some(e) = &d.estimate {
let e = e.data();
if e.tool != d.tool
|| e.from_amount != a.from_amount
|| !amount_for(e.to_amount, &a.to_token)
|| !amount_for(e.to_amount_min, &a.to_token)
|| e.approval_account
.as_ref()
.is_some_and(|p| p.chain() != a.from_token.data().asset.chain())
{
return Err(super::invalid_record());
}
}
if let Some(payload) = &d.payload {
if payload.chain() != a.from_token.data().asset.chain() {
return Err(super::invalid_payload());
}
if let Payload::Evm(p) = payload
&& let Some(from) = &p.data().from
&& a.from_account
.as_ref()
.is_some_and(|expected| expected != from)
{
return Err(super::invalid_payload());
}
}
for child in &d.included_steps {
child.validate_tree(depth + 1, ids)?;
}
Ok(())
}
#[must_use]
pub const fn data(&self) -> &StepData {
&self.0
}
pub fn check_limits(&self, limits: Limits) -> Result<usize, Error> {
let mut count = 1;
if let Some(e) = &self.0.estimate
&& (e
.data()
.fees
.as_ref()
.is_some_and(|v| v.len() > usize::from(limits.costs))
|| e.data()
.gas_costs
.as_ref()
.is_some_and(|v| v.len() > usize::from(limits.costs)))
{
return Err(super::invalid_record());
}
for child in &self.0.included_steps {
count += child.check_limits(limits)?;
}
if count > usize::from(limits.steps) {
return Err(super::invalid_record());
}
Ok(count)
}
}
impl TryFrom<StepData> for Step {
type Error = Error;
fn try_from(v: StepData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Step> for StepData {
fn from(v: Step) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Origin {
pub source: Source,
pub retrieved_at: Timestamp,
}
pub trait StepView: Clone + crate::future::MaybeSend + crate::future::MaybeSync {
fn step(&self) -> &Step;
fn request(&self) -> &Request;
fn origin(&self) -> &Origin;
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RouteData {
pub id: Identifier,
pub from: Token,
pub from_account: Option<Account>,
pub from_amount: Amount,
pub to: Token,
pub to_account: Option<Account>,
pub to_amount: Amount,
pub to_amount_min: Amount,
pub from_amount_usd: Option<ExactDecimal>,
pub to_amount_usd: Option<ExactDecimal>,
pub gas_cost_usd: Option<ExactDecimal>,
pub contains_switch_chain: Option<bool>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct Route<H> {
data: RouteData,
steps: Vec<H>,
}
impl<H: StepView> Route<H> {
pub fn new(data: RouteData, steps: Vec<H>) -> Result<Self, Error> {
if steps.is_empty()
|| steps.len() > 256
|| !amount_for(data.from_amount, &data.from)
|| !amount_for(data.to_amount, &data.to)
|| !amount_for(data.to_amount_min, &data.to)
|| data.to_amount_min.raw() > data.to_amount.raw()
|| !optional_nonnegative(data.from_amount_usd.as_ref())
|| !optional_nonnegative(data.to_amount_usd.as_ref())
|| !optional_nonnegative(data.gas_cost_usd.as_ref())
|| data
.from_account
.as_ref()
.is_some_and(|a| a.chain() != data.from.data().asset.chain())
|| data
.to_account
.as_ref()
.is_some_and(|a| a.chain() != data.to.data().asset.chain())
{
return Err(super::invalid_record());
}
let first = steps
.first()
.ok_or_else(super::invalid_record)?
.step()
.data()
.action
.data();
let last = steps
.last()
.ok_or_else(super::invalid_record)?
.step()
.data()
.action
.data();
if first.from_token.data().asset != data.from.data().asset
|| first.from_token.data().decimals != data.from.data().decimals
|| first.from_amount != data.from_amount
|| last.to_token.data().asset != data.to.data().asset
|| last.to_token.data().decimals != data.to.data().decimals
{
return Err(super::invalid_record());
}
let mut ids = BTreeSet::new();
for h in &steps {
h.step().validate_tree(0, &mut ids)?;
}
for pair in steps.windows(2) {
if pair[0].step().data().action.data().to_token.data().asset
!= pair[1].step().data().action.data().from_token.data().asset
|| pair[0].step().data().action.data().to_token.data().decimals
!= pair[1]
.step()
.data()
.action
.data()
.from_token
.data()
.decimals
{
return Err(super::invalid_record());
}
}
Ok(Self { data, steps })
}
#[must_use]
pub const fn data(&self) -> &RouteData {
&self.data
}
#[must_use]
pub fn steps(&self) -> &[H] {
&self.steps
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RouteFields<H> {
data: RouteData,
steps: Vec<H>,
}
impl<'de, H: Deserialize<'de> + StepView> Deserialize<'de> for Route<H> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let v = RouteFields::<H>::deserialize(d)?;
Self::new(v.data, v.steps).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ToolFailure {
pub overall_path: Text,
pub subpath: Text,
pub tool: Identifier,
pub kind: Identifier,
pub code: Identifier,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnavailableRoutes {
pub filtered_paths: Vec<Text>,
pub failed_paths: Vec<Text>,
pub failures: Vec<ToolFailure>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct Routes<H> {
request: Request,
origin: Origin,
alternatives: Vec<Route<H>>,
unavailable: Option<UnavailableRoutes>,
limits: Limits,
}
impl<H: StepView> Routes<H> {
pub fn new(
request: Request,
origin: Origin,
routes: Vec<Route<H>>,
unavailable: Option<UnavailableRoutes>,
limits: Limits,
) -> Result<Self, Error> {
if routes.len() > usize::from(limits.routes)
|| unavailable.as_ref().is_some_and(|u| {
u.filtered_paths.len() > 4096
|| u.failed_paths.len() > 4096
|| u.failures.len() > 4096
})
{
return Err(super::invalid_record());
}
let mut ids = BTreeSet::new();
for route in &routes {
let d = route.data();
let r = request.data();
if !ids.insert(d.id.clone())
|| d.from.data().asset != r.from
|| d.to.data().asset != r.to
|| d.from_amount.raw() != r.amount.raw()
|| r.amount
.decimals()
.is_some_and(|p| p != d.from.data().decimals)
|| d.from_account
.as_ref()
.is_some_and(|a| a != &r.from_account)
|| r.to_account.as_ref().is_some_and(|expected| {
d.to_account
.as_ref()
.is_some_and(|actual| actual != expected)
})
|| (!r.allow_switch_chain && d.contains_switch_chain == Some(true))
{
return Err(super::invalid_record());
}
let mut count = 0;
for h in route.steps() {
if h.request() != &request || h.origin() != &origin {
return Err(super::invalid_record());
}
count += h.step().check_limits(limits)?;
}
if count > usize::from(limits.steps) {
return Err(super::invalid_record());
}
let first = route
.steps()
.first()
.ok_or_else(super::invalid_record)?
.step()
.data()
.action
.data();
let last = route
.steps()
.last()
.ok_or_else(super::invalid_record)?
.step()
.data()
.action
.data();
if first
.from_account
.as_ref()
.is_some_and(|actual| actual != &r.from_account)
|| r.to_account.as_ref().is_some_and(|expected| {
last.to_account
.as_ref()
.is_some_and(|actual| actual != expected)
})
|| route.steps().iter().any(|h| {
h.step()
.data()
.action
.data()
.slippage
.as_ref()
.is_some_and(|s| s != &r.slippage)
})
{
return Err(super::invalid_record());
}
}
Ok(Self {
request,
origin,
alternatives: routes,
unavailable,
limits,
})
}
#[must_use]
pub const fn request(&self) -> &Request {
&self.request
}
#[must_use]
pub const fn origin(&self) -> &Origin {
&self.origin
}
#[must_use]
pub fn routes(&self) -> &[Route<H>] {
&self.alternatives
}
#[must_use]
pub const fn unavailable(&self) -> Option<&UnavailableRoutes> {
self.unavailable.as_ref()
}
#[must_use]
pub const fn limits(&self) -> Limits {
self.limits
}
}
#[derive(Deserialize)]
#[serde(
deny_unknown_fields,
bound(deserialize = "H: Deserialize<'de> + StepView")
)]
struct RoutesFields<H> {
request: Request,
origin: Origin,
alternatives: Vec<Route<H>>,
unavailable: Option<UnavailableRoutes>,
limits: Limits,
}
impl<'de, H: Deserialize<'de> + StepView> Deserialize<'de> for Routes<H> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let v = RoutesFields::<H>::deserialize(d)?;
Self::new(v.request, v.origin, v.alternatives, v.unavailable, v.limits)
.map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PreparedFields")]
pub struct PreparedStep {
original_request: Request,
selected_step: Step,
selected_origin: Origin,
refreshed_step: Step,
origin: Origin,
network: (Chain, Chain),
#[serde(skip_serializing)]
payload: Payload,
}
impl PreparedStep {
pub fn new<H: StepView>(
selected: &H,
refreshed_step: Step,
origin: Origin,
) -> Result<Self, Error> {
Self::from_fields(
selected.request().clone(),
selected.step().clone(),
selected.origin().clone(),
refreshed_step,
origin,
)
}
fn from_fields(
original_request: Request,
selected_step: Step,
selected_origin: Origin,
refreshed_step: Step,
origin: Origin,
) -> Result<Self, Error> {
let a = selected_step.data();
let b = refreshed_step.data();
if a.id != b.id
|| a.tool != b.tool
|| a.kind != b.kind
|| !a.action.same_intent(&b.action)
|| b.payload.is_none()
|| b.estimate.is_none()
{
return Err(super::invalid_record());
}
let payload = b
.payload
.as_ref()
.ok_or_else(super::invalid_payload)?
.clone();
let network = (
b.action.data().from_token.data().asset.chain(),
b.action.data().to_token.data().asset.chain(),
);
Ok(Self {
original_request,
selected_step,
selected_origin,
refreshed_step,
origin,
network,
payload,
})
}
#[must_use]
pub const fn original_request(&self) -> &Request {
&self.original_request
}
#[must_use]
pub const fn selected_step(&self) -> &Step {
&self.selected_step
}
#[must_use]
pub const fn selected_origin(&self) -> &Origin {
&self.selected_origin
}
#[must_use]
pub const fn refreshed_step(&self) -> &Step {
&self.refreshed_step
}
#[must_use]
pub const fn origin(&self) -> &Origin {
&self.origin
}
#[must_use]
pub const fn payload(&self) -> &Payload {
&self.payload
}
}
impl Preparation for PreparedStep {
type Network = (Chain, Chain);
type Intent = Step;
type UnsignedPayload = Payload;
fn network(&self) -> &Self::Network {
&self.network
}
fn intent(&self) -> &Self::Intent {
&self.refreshed_step
}
fn unsigned_payload(&self) -> &Self::UnsignedPayload {
self.payload()
}
fn validate(&self) -> Result<(), Error> {
Self::from_fields(
self.original_request.clone(),
self.selected_step.clone(),
self.selected_origin.clone(),
self.refreshed_step.clone(),
self.origin.clone(),
)
.map(|_| ())
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct PreparedFields {
original_request: Request,
selected_step: Step,
selected_origin: Origin,
refreshed_step: Step,
origin: Origin,
network: (Chain, Chain),
}
impl TryFrom<PreparedFields> for PreparedStep {
type Error = Error;
fn try_from(v: PreparedFields) -> Result<Self, Error> {
let p = Self::from_fields(
v.original_request,
v.selected_step,
v.selected_origin,
v.refreshed_step,
v.origin,
)?;
if p.network != v.network {
return Err(super::invalid_record());
}
Ok(p)
}
}