Remove duplicate ExactScheme and U64String implementations and extract scheme_slug_from_json helper function

* Delete ExactScheme struct with Display, AsRef, FromStr, Serialize, and Deserialize impls from r402-svm/src/exact/types.rs
* Add pub use r402::scheme::ExactScheme in r402-svm/src/exact/types.rs
* Replace manual Serialize/Deserialize impls for U64String with serde_with::DisplayFromStr in r402/src/proto/mod.rs
* Add serde_as attribute to U64String struct in r402/src/proto/mod.rs
* Extract

Author: gitctrlx

r402-svm/src/exact/types.rs

@@ -3,6 +3,7 @@
 //! This module defines shared wire format types for SPL Token based payments
 //! on Solana. Wire format type aliases live in the [`v2`] sub-module.
 
+pub use r402::scheme::ExactScheme;
 use serde::{Deserialize, Serialize};
 use solana_pubkey::{Pubkey, pubkey};
 use std::sync::LazyLock;
@@ -26,58 +27,6 @@ use solana_signer::Signer;
 #[cfg(any(feature = "client", feature = "facilitator"))]
 use solana_transaction::versioned::VersionedTransaction;
 
-/// A unit struct representing the string literal "exact".
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ExactScheme;
-
-impl ExactScheme {
-    /// The string literal value: `"exact"`.
-    pub const VALUE: &'static str = "exact";
-}
-
-impl AsRef<str> for ExactScheme {
-    fn as_ref(&self) -> &str {
-        Self::VALUE
-    }
-}
-
-impl std::str::FromStr for ExactScheme {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s == Self::VALUE {
-            Ok(Self)
-        } else {
-            Err(format!("expected '{}', got '{s}'", Self::VALUE))
-        }
-    }
-}
-
-impl std::fmt::Display for ExactScheme {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(Self::VALUE)
-    }
-}
-
-impl Serialize for ExactScheme {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(Self::VALUE)
-    }
-}
-
-impl<'de> Deserialize<'de> for ExactScheme {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let s = String::deserialize(deserializer)?;
-        if s == Self::VALUE {
-            Ok(Self)
-        } else {
-            Err(serde::de::Error::custom(format!(
-                "expected '{}', got '{s}'",
-                Self::VALUE,
-            )))
-        }
-    }
-}
-
 /// Phantom Lighthouse program ID - security program injected by Phantom wallet on mainnet
 /// See: <https://github.com/coinbase/x402/issues/828>
 pub static PHANTOM_LIGHTHOUSE_PROGRAM: LazyLock<Pubkey> = LazyLock::new(|| {

r402/src/proto/mod.rs

@@ -17,7 +17,7 @@
 //! All types serialize to JSON using camelCase field names. The protocol version
 //! is indicated by the `x402Version` field in payment payloads.
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 use serde_with::{VecSkipError, serde_as};
 use std::collections::HashMap;
 use std::str::FromStr;
@@ -103,8 +103,9 @@ pub type Extensions = HashMap<String, serde_json::Value>;
 /// Some JSON parsers (particularly in `JavaScript`) cannot accurately represent
 /// large integers. This type serializes `u64` values as strings to preserve
 /// precision across all platforms.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct U64String(u64);
+#[serde_as]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub struct U64String(#[serde_as(as = "serde_with::DisplayFromStr")] u64);
 
 impl U64String {
     /// Returns the inner `u64` value.
@@ -134,25 +135,6 @@ impl From<U64String> for u64 {
     }
 }
 
-impl Serialize for U64String {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&self.0.to_string())
-    }
-}
-
-impl<'de> Deserialize<'de> for U64String {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        s.parse::<u64>().map(Self).map_err(serde::de::Error::custom)
-    }
-}
-
 /// Describes a payment method supported by a facilitator.
 ///
 /// This type is returned in the [`SupportedResponse`] to indicate what
@@ -246,8 +228,7 @@ impl SettleRequest {
     /// Delegates to the same logic as [`VerifyRequest::scheme_slug`].
     #[must_use]
     pub fn scheme_slug(&self) -> Option<SchemeSlug> {
-        let tmp = VerifyRequest(self.0.clone());
-        tmp.scheme_slug()
+        scheme_slug_from_json(&self.0)
     }
 }
 
@@ -284,26 +265,23 @@ impl VerifyRequest {
     /// Returns `None` if the request format is invalid or the scheme is unknown.
     #[must_use]
     pub fn scheme_slug(&self) -> Option<SchemeSlug> {
-        let x402_version: u8 = self.0.get("x402Version")?.as_u64()?.try_into().ok()?;
-        if x402_version != v2::X402Version2::VALUE {
-            return None;
-        }
-        let chain_id_string = self
-            .0
-            .get("paymentPayload")?
-            .get("accepted")?
-            .get("network")?
-            .as_str()?;
-        let chain_id = ChainId::from_str(chain_id_string).ok()?;
-        let scheme = self
-            .0
-            .get("paymentPayload")?
-            .get("accepted")?
-            .get("scheme")?
-            .as_str()?;
-        let slug = SchemeSlug::new(chain_id, scheme.into());
-        Some(slug)
+        scheme_slug_from_json(&self.0)
+    }
+}
+
+/// Extracts a [`SchemeSlug`] from a raw verify/settle JSON value.
+///
+/// Navigates `x402Version`, `paymentPayload.accepted.network`, and
+/// `paymentPayload.accepted.scheme` without cloning the JSON tree.
+fn scheme_slug_from_json(json: &serde_json::Value) -> Option<SchemeSlug> {
+    let x402_version: u8 = json.get("x402Version")?.as_u64()?.try_into().ok()?;
+    if x402_version != v2::X402Version2::VALUE {
+        return None;
     }
+    let accepted = json.get("paymentPayload")?.get("accepted")?;
+    let chain_id = ChainId::from_str(accepted.get("network")?.as_str()?).ok()?;
+    let scheme = accepted.get("scheme")?.as_str()?;
+    Some(SchemeSlug::new(chain_id, scheme.into()))
 }
 
 /// Result returned by a facilitator after verifying a payment payload