Introduce Payjoin version enum

Author: shinghim

payjoin/src/lib.rs

@@ -22,6 +22,7 @@ compile_error!("At least one of the features ['directory', 'v1', 'v2'] must be e
 
 #[cfg(feature = "_core")]
 pub extern crate bitcoin;
+extern crate core;
 
 #[cfg(feature = "_core")]
 pub mod receive;
@@ -70,3 +71,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) =>
@@ -117,7 +119,7 @@ impl Params {
 
 #[derive(Debug)]
 pub(crate) enum Error {
-    UnknownVersion { supported_versions: &'static [usize] },
+    UnknownVersion { supported_versions: &'static [Version] },
     FeeRate,
 }
 

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)
+    }
+}