Introduce Payjoin version enum

Author: shinghim

payjoin/src/lib.rs

@@ -70,3 +70,7 @@ pub use uri::{PjParseError, PjUri, Uri, UriExt};
 pub use url::{ParseError, Url};
 #[cfg(feature = "_core")]
 pub(crate) mod error_codes;
+#[cfg(feature = "_core")]
+pub(crate) mod version;
+#[cfg(feature = "_core")]
+pub use version::Version;

payjoin/src/receive/mod.rs

@@ -21,6 +21,7 @@ use optional_parameters::Params;
 
 pub use crate::psbt::PsbtInputError;
 use crate::psbt::{InternalInputPair, InternalPsbtInputError, PsbtExt};
+use crate::Version;
 
 mod error;
 pub(crate) mod optional_parameters;
@@ -73,7 +74,7 @@ impl<'a> From<&'a InputPair> for InternalInputPair<'a> {
 pub(crate) fn parse_payload(
     base64: String,
     query: &str,
-    supported_versions: &'static [usize],
+    supported_versions: &'static [Version],
 ) -> Result<(Psbt, Params), PayloadError> {
     let unchecked_psbt = Psbt::from_str(&base64).map_err(InternalPayloadError::ParsePsbt)?;
 

payjoin/src/receive/optional_parameters.rs

@@ -5,11 +5,12 @@ use bitcoin::FeeRate;
 use log::warn;
 
 use crate::output_substitution::OutputSubstitution;
+use crate::Version;
 
 #[derive(Debug, Clone)]
 pub(crate) struct Params {
     // version
-    pub v: usize,
+    pub v: Version,
     // disableoutputsubstitution
     pub output_substitution: OutputSubstitution,
     // maxadditionalfeecontribution, additionalfeeoutputindex
@@ -24,7 +25,7 @@ pub(crate) struct Params {
 impl Default for Params {
     fn default() -> Self {
         Params {
-            v: 1,
+            v: Version::One,
             output_substitution: OutputSubstitution::Enabled,
             additional_fee_contribution: None,
             min_fee_rate: FeeRate::BROADCAST_MIN,
@@ -37,7 +38,7 @@ impl Default for Params {
 impl Params {
     pub fn from_query_pairs<K, V, I>(
         pairs: I,
-        supported_versions: &'static [usize],
+        supported_versions: &'static [Version],
     ) -> Result<Self, Error>
     where
         I: Iterator<Item = (K, V)>,
@@ -52,8 +53,9 @@ impl Params {
         for (key, v) in pairs {
             match (key.borrow(), v.borrow()) {
                 ("v", version) =>
-                    params.v = match version.parse::<usize>() {
-                        Ok(version) if supported_versions.contains(&version) => version,
+                    params.v = match version {
+                        "1" => Version::One,
+                        "2" => Version::Two,
                         _ => return Err(Error::UnknownVersion { supported_versions }),
                     },
                 ("additionalfeeoutputindex", index) =>
@@ -115,9 +117,9 @@ impl Params {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum Error {
-    UnknownVersion { supported_versions: &'static [usize] },
+    UnknownVersion { supported_versions: &'static [Version] },
     FeeRate,
 }
 
@@ -133,3 +135,30 @@ impl fmt::Display for Error {
 impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::receive::optional_parameters::Params;
+    use crate::Version;
+
+    #[test]
+    fn from_query_pairs_matches_correct_versions() {
+        let v1_pair: Vec<(&str, &str)> = vec![("v", "1")];
+        let params = Params::from_query_pairs(v1_pair.into_iter(), &[Version::One]).unwrap();
+        assert_eq!(params.v, Version::One);
+
+        let v2_pair: Vec<(&str, &str)> = vec![("v", "2")];
+        let params = Params::from_query_pairs(v2_pair.into_iter(), &[Version::Two]).unwrap();
+        assert_eq!(params.v, Version::Two);
+    }
+
+    #[test]
+    fn from_query_pairs_unsupported_versions() {
+        let v1_pair: Vec<(&str, &str)> = vec![("v", "888")];
+        let supported_versions = &[Version::One, Version::Two];
+        let params = Params::from_query_pairs(v1_pair.into_iter(), supported_versions);
+        assert!(params.is_err());
+        assert_eq!(params.err().unwrap(), Error::UnknownVersion { supported_versions });
+    }
+}

payjoin/src/receive/v1/mod.rs

@@ -781,11 +781,12 @@ pub(crate) mod test {
 
     use super::*;
     use crate::receive::PayloadError;
+    use crate::Version;
 
     pub(crate) fn unchecked_proposal_from_test_vector() -> UncheckedProposal {
         let pairs = url::form_urlencoded::parse(QUERY_PARAMS.as_bytes());
-        let params =
-            Params::from_query_pairs(pairs, &[1]).expect("Could not parse params from query pairs");
+        let params = Params::from_query_pairs(pairs, &[Version::One])
+            .expect("Could not parse params from query pairs");
         UncheckedProposal { psbt: PARSED_ORIGINAL_PSBT.clone(), params }
     }
 

payjoin/src/receive/v2/mod.rs

@@ -23,11 +23,11 @@ use crate::output_substitution::OutputSubstitution;
 use crate::persist::{self, Persister};
 use crate::receive::{parse_payload, InputPair};
 use crate::uri::ShortId;
-use crate::{IntoUrl, IntoUrlError, Request};
+use crate::{IntoUrl, IntoUrlError, Request, Version};
 
 pub(crate) mod error;
 
-const SUPPORTED_VERSIONS: &[usize] = &[1, 2];
+const SUPPORTED_VERSIONS: &[Version] = &[Version::One, Version::Two];
 
 static TWENTY_FOUR_HOURS_DEFAULT_EXPIRY: Duration = Duration::from_secs(60 * 60 * 24);
 
@@ -238,7 +238,7 @@ impl Receiver {
         // V2 proposals are authenticated and encrypted to prevent such attacks.
         //
         // see: https://github.com/bitcoin/bips/blob/master/bip-0078.mediawiki#unsecured-payjoin-server
-        if params.v == 1 {
+        if params.v == Version::One {
             params.output_substitution = OutputSubstitution::Disabled;
 
             // Additionally V1 sessions never have an optimistic merge opportunity

payjoin/src/version.rs

@@ -0,0 +1,45 @@
+use core::fmt;
+
+use serde::{Serialize, Serializer};
+
+/// The Payjoin version
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Version {
+    One,
+    Two,
+}
+
+impl Version {
+    pub fn as_usize(&self) -> usize {
+        match self {
+            Version::One => 1,
+            Version::Two => 2,
+        }
+    }
+}
+
+/// From [BIP-78](https://github.com/bitcoin/bips/blob/master/bip-0078.mediawiki#optional-parameters),
+/// the supported versions should be output as numbers:
+/// ```json
+/// {
+///     "errorCode": "version-unsupported",
+///     "supported" : [ 2, 3, 4 ],
+///     "message": "The version is not supported anymore"
+/// }
+/// ```
+impl fmt::Display for Version {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.as_usize()) }
+}
+
+impl fmt::Debug for Version {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self, f) }
+}
+
+impl Serialize for Version {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.as_usize().serialize(serializer)
+    }
+}