Add deeplink and wallet-connect URL parsing (#1148)

Author: DRadmir

crates/in_app_notifications/src/lib.rs

@@ -41,7 +41,7 @@ fn notification_item(
 
 fn map_to_list_item(notification: &NotificationData, localizer: &LanguageLocalizer) -> CoreListItem {
     let id = notification.id.to_string();
-    let url = Some(Deeplink::Rewards.to_url());
+    let url = Some(Deeplink::Rewards { code: None }.to_gem_url());
 
     match notification.notification_type {
         NotificationType::ReferralJoined => {

crates/primitives/src/deeplink.rs

@@ -1,17 +1,181 @@
-use serde::{Deserialize, Serialize};
-use strum::{AsRefStr, EnumString};
+use url::Url;
 
-pub const DEEP_LINK_SCHEME: &str = "gem://";
+use crate::AssetId;
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, AsRefStr, EnumString)]
-#[strum(serialize_all = "camelCase")]
-#[serde(rename_all = "camelCase")]
+const DEEPLINK_HOST: &str = "gemwallet.com";
+const DEEPLINK_WEB_SCHEME: &str = "https";
+const DEEPLINK_GEM_SCHEME: &str = "gem";
+
+const PATH_TOKENS: &str = "tokens";
+const PATH_PERPETUALS: &str = "perpetuals";
+const PATH_REWARDS: &str = "rewards";
+const PATH_JOIN: &str = "join";
+
+const QUERY_CODE: &str = "code";
+
+#[derive(Debug, Clone, PartialEq)]
 pub enum Deeplink {
-    Rewards,
+    Asset { asset_id: AssetId },
+    Perpetuals,
+    Rewards { code: Option<String> },
 }
 
 impl Deeplink {
     pub fn to_url(&self) -> String {
-        format!("{}{}", DEEP_LINK_SCHEME, self.as_ref())
+        format!("{DEEPLINK_WEB_SCHEME}://{DEEPLINK_HOST}{}", self.path())
+    }
+
+    pub fn to_gem_url(&self) -> String {
+        format!("{DEEPLINK_GEM_SCHEME}://{}", self.path().trim_start_matches('/'))
+    }
+
+    pub fn from_url(url: &str) -> Option<Self> {
+        let url = Url::parse(url).ok()?;
+        let segments = url_segments(&url)?;
+        let (component, params) = segments.split_first()?;
+
+        let deeplink = match component.as_str() {
+            PATH_TOKENS => Deeplink::Asset {
+                asset_id: AssetId::from(params.first()?.parse().ok()?, params.get(1).cloned()),
+            },
+            PATH_PERPETUALS => Deeplink::Perpetuals,
+            PATH_REWARDS | PATH_JOIN => Deeplink::Rewards {
+                code: params.first().cloned().or_else(|| query_value(&url, QUERY_CODE)),
+            },
+            _ => return None,
+        };
+        Some(deeplink)
+    }
+
+    fn path(&self) -> String {
+        match self {
+            Deeplink::Asset { asset_id } => match &asset_id.token_id {
+                Some(token_id) => format!("/{PATH_TOKENS}/{}/{token_id}", asset_id.chain.as_ref()),
+                None => format!("/{PATH_TOKENS}/{}", asset_id.chain.as_ref()),
+            },
+            Deeplink::Perpetuals => format!("/{PATH_PERPETUALS}"),
+            Deeplink::Rewards { code } => path_with_query(PATH_REWARDS, QUERY_CODE, code.clone()),
+        }
+    }
+}
+
+fn path_with_query(component: &str, query_key: &str, query_value: Option<String>) -> String {
+    match query_value {
+        Some(value) => format!("/{component}?{query_key}={value}"),
+        None => format!("/{component}"),
+    }
+}
+
+fn url_segments(url: &Url) -> Option<Vec<String>> {
+    let mut segments: Vec<String> = url
+        .path_segments()
+        .map(|parts| parts.filter(|part| !part.is_empty()).map(String::from).collect())
+        .unwrap_or_default();
+
+    match url.scheme() {
+        DEEPLINK_WEB_SCHEME => {
+            if url.host_str()? != DEEPLINK_HOST {
+                return None;
+            }
+        }
+        DEEPLINK_GEM_SCHEME => {
+            if let Some(host) = url.host_str().filter(|host| !host.is_empty()) {
+                segments.insert(0, host.to_string());
+            }
+        }
+        _ => return None,
+    }
+    Some(segments)
+}
+
+fn query_value(url: &Url, key: &str) -> Option<String> {
+    url.query_pairs().find(|(query_key, _)| query_key.as_ref() == key).map(|(_, value)| value.into_owned())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Chain;
+
+    #[test]
+    fn test_to_url() {
+        assert_eq!(
+            Deeplink::Asset {
+                asset_id: AssetId::from_chain(Chain::Bitcoin)
+            }
+            .to_url(),
+            "https://gemwallet.com/tokens/bitcoin"
+        );
+        assert_eq!(
+            Deeplink::Asset {
+                asset_id: AssetId::token(Chain::Ethereum, "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+            }
+            .to_url(),
+            "https://gemwallet.com/tokens/ethereum/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+        );
+        assert_eq!(Deeplink::Perpetuals.to_url(), "https://gemwallet.com/perpetuals");
+        assert_eq!(Deeplink::Rewards { code: None }.to_url(), "https://gemwallet.com/rewards");
+        assert_eq!(
+            Deeplink::Rewards {
+                code: Some("gemcoder".to_string()),
+            }
+            .to_url(),
+            "https://gemwallet.com/rewards?code=gemcoder"
+        );
+    }
+
+    #[test]
+    fn test_to_gem_url() {
+        assert_eq!(Deeplink::Rewards { code: None }.to_gem_url(), "gem://rewards");
+        assert_eq!(Deeplink::Perpetuals.to_gem_url(), "gem://perpetuals");
+        assert_eq!(
+            Deeplink::Asset {
+                asset_id: AssetId::from_chain(Chain::Bitcoin)
+            }
+            .to_gem_url(),
+            "gem://tokens/bitcoin"
+        );
+    }
+
+    #[test]
+    fn test_from_url() {
+        assert_eq!(
+            Deeplink::from_url("https://gemwallet.com/tokens/bitcoin"),
+            Some(Deeplink::Asset {
+                asset_id: AssetId::from_chain(Chain::Bitcoin)
+            })
+        );
+        assert_eq!(
+            Deeplink::from_url("https://gemwallet.com/tokens/ethereum/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+            Some(Deeplink::Asset {
+                asset_id: AssetId::token(Chain::Ethereum, "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+            })
+        );
+        assert_eq!(
+            Deeplink::from_url("gem://tokens/bitcoin"),
+            Some(Deeplink::Asset {
+                asset_id: AssetId::from_chain(Chain::Bitcoin)
+            })
+        );
+        assert_eq!(Deeplink::from_url("https://gemwallet.com/perpetuals"), Some(Deeplink::Perpetuals));
+        assert_eq!(Deeplink::from_url("gem://perpetuals"), Some(Deeplink::Perpetuals));
+        assert_eq!(
+            Deeplink::from_url("https://gemwallet.com/rewards?code=gemcoder"),
+            Some(Deeplink::Rewards {
+                code: Some("gemcoder".to_string()),
+            })
+        );
+        assert_eq!(
+            Deeplink::from_url("https://gemwallet.com/join/gemcoder"),
+            Some(Deeplink::Rewards {
+                code: Some("gemcoder".to_string()),
+            })
+        );
+        assert_eq!(Deeplink::from_url("https://gemwallet.com/join"), Some(Deeplink::Rewards { code: None }));
+        assert_eq!(Deeplink::from_url("https://gemwallet.com/tokens"), None);
+        assert_eq!(Deeplink::from_url("https://gemwallet.com/tokens/notachain"), None);
+        assert_eq!(Deeplink::from_url("https://example.com/tokens/bitcoin"), None);
+        assert_eq!(Deeplink::from_url("https://gemwallet.com/unknown"), None);
+        assert_eq!(Deeplink::from_url("not a url"), None);
     }
 }

crates/primitives/src/lib.rs

@@ -160,7 +160,7 @@ pub use self::transaction_metadata_types::{
 pub mod wallet_connect_namespace;
 pub use self::wallet_connect_namespace::WalletConnectCAIP2;
 pub mod wallet_connect;
-pub use self::wallet_connect::{WCEthereumTransaction, WCTonMessage, WalletConnectRequest};
+pub use self::wallet_connect::{WCEthereumTransaction, WCTonMessage, WalletConnectLink, WalletConnectRequest};
 pub mod account;
 pub use self::account::Account;
 pub mod wallet;
@@ -306,6 +306,8 @@ pub mod notification_data;
 pub use self::notification_data::{NotificationData, NotificationRewardsMetadata, NotificationRewardsRedeemMetadata};
 pub mod deeplink;
 pub use self::deeplink::Deeplink;
+pub mod url_action;
+pub use self::url_action::UrlAction;
 pub mod list_item;
 pub use self::list_item::{CoreEmoji, CoreListItem, CoreListItemBadge, CoreListItemIcon};
 pub mod notification;

crates/primitives/src/url_action.rs

@@ -0,0 +1,50 @@
+use crate::{Deeplink, WalletConnectLink};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum UrlAction {
+    Deeplink { deeplink: Deeplink },
+    WalletConnect { link: WalletConnectLink },
+}
+
+impl UrlAction {
+    pub fn from_url(url: &str) -> Option<Self> {
+        if let Some(link) = WalletConnectLink::from_url(url) {
+            return Some(Self::WalletConnect { link });
+        }
+        Deeplink::from_url(url).map(|deeplink| Self::Deeplink { deeplink })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{AssetId, Chain};
+
+    #[test]
+    fn test_from_url() {
+        assert_eq!(
+            UrlAction::from_url("https://gemwallet.com/tokens/bitcoin"),
+            Some(UrlAction::Deeplink {
+                deeplink: Deeplink::Asset {
+                    asset_id: AssetId::from_chain(Chain::Bitcoin),
+                },
+            })
+        );
+        assert_eq!(
+            UrlAction::from_url("gem://wc?sessionTopic=abc123"),
+            Some(UrlAction::WalletConnect {
+                link: WalletConnectLink::Session { topic: "abc123".to_string() },
+            })
+        );
+        assert_eq!(
+            UrlAction::from_url("wc:topic@2?relay-protocol=irn&symKey=abc"),
+            Some(UrlAction::WalletConnect {
+                link: WalletConnectLink::Connect {
+                    uri: "wc:topic@2?relay-protocol=irn&symKey=abc".to_string(),
+                },
+            })
+        );
+        assert_eq!(UrlAction::from_url("https://example.com/tokens/bitcoin"), None);
+        assert_eq!(UrlAction::from_url("not a url"), None);
+    }
+}

crates/primitives/src/wallet_connect.rs

@@ -1,5 +1,14 @@
 use serde::{Deserialize, Serialize};
 use typeshare::typeshare;
+use url::Url;
+
+const WALLET_CONNECT_SCHEME: &str = "wc";
+const WALLET_CONNECT_HOST: &str = "wc";
+const GEM_SCHEME: &str = "gem";
+
+const QUERY_URI: &str = "uri";
+const QUERY_SESSION_TOPIC: &str = "sessionTopic";
+const QUERY_REQUEST_ID: &str = "requestId";
 
 #[derive(Debug, Serialize, Deserialize)]
 #[typeshare(swift = "Equatable, Hashable, Sendable")]
@@ -37,3 +46,73 @@ pub struct WalletConnectRequest {
     pub chain_id: Option<String>,
     pub domain: String,
 }
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum WalletConnectLink {
+    Connect { uri: String },
+    Request,
+    Session { topic: String },
+}
+
+impl WalletConnectLink {
+    pub fn from_url(url: &str) -> Option<Self> {
+        let parsed = Url::parse(url).ok()?;
+        match parsed.scheme() {
+            WALLET_CONNECT_SCHEME => Some(Self::session_or_request(&parsed).unwrap_or_else(|| WalletConnectLink::Connect { uri: url.to_string() })),
+            GEM_SCHEME if parsed.host_str() == Some(WALLET_CONNECT_HOST) => match query_value(&parsed, QUERY_URI).filter(|uri| !uri.is_empty()) {
+                Some(uri) => Some(WalletConnectLink::Connect { uri }),
+                None => Self::session_or_request(&parsed),
+            },
+            _ => None,
+        }
+    }
+
+    fn session_or_request(url: &Url) -> Option<Self> {
+        if let Some(topic) = query_value(url, QUERY_SESSION_TOPIC).filter(|topic| !topic.is_empty()) {
+            Some(WalletConnectLink::Session { topic })
+        } else if query_value(url, QUERY_REQUEST_ID).is_some() {
+            Some(WalletConnectLink::Request)
+        } else {
+            None
+        }
+    }
+}
+
+fn query_value(url: &Url, key: &str) -> Option<String> {
+    url.query_pairs().find(|(query_key, _)| query_key.as_ref() == key).map(|(_, value)| value.into_owned())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_wallet_connect_link_from_url() {
+        assert_eq!(
+            WalletConnectLink::from_url("wc:abc@2?relay-protocol=irn&symKey=123"),
+            Some(WalletConnectLink::Connect {
+                uri: "wc:abc@2?relay-protocol=irn&symKey=123".to_string(),
+            })
+        );
+        assert_eq!(WalletConnectLink::from_url("wc:abc@2?requestId"), Some(WalletConnectLink::Request));
+        assert_eq!(WalletConnectLink::from_url("wc:abc@2?requestId=123"), Some(WalletConnectLink::Request));
+        assert_eq!(
+            WalletConnectLink::from_url("gem://wc?uri=wc:topic@2"),
+            Some(WalletConnectLink::Connect { uri: "wc:topic@2".to_string() })
+        );
+        assert_eq!(
+            WalletConnectLink::from_url("gem://wc?uri=wc%3Atopic%402%3Frelay-protocol%3Dirn%26symKey%3Dabc"),
+            Some(WalletConnectLink::Connect {
+                uri: "wc:topic@2?relay-protocol=irn&symKey=abc".to_string(),
+            })
+        );
+        assert_eq!(WalletConnectLink::from_url("gem://wc?requestId=1"), Some(WalletConnectLink::Request));
+        assert_eq!(
+            WalletConnectLink::from_url("gem://wc?sessionTopic=abc123"),
+            Some(WalletConnectLink::Session { topic: "abc123".to_string() })
+        );
+        assert_eq!(WalletConnectLink::from_url("gem://wc?sessionTopic="), None);
+        assert_eq!(WalletConnectLink::from_url("gem://asset/solana"), None);
+        assert_eq!(WalletConnectLink::from_url("https://gemwallet.com/tokens/bitcoin"), None);
+    }
+}

gemstone/src/deeplink.rs

@@ -0,0 +1,32 @@
+use primitives::{AssetId, Deeplink};
+
+#[uniffi::remote(Enum)]
+pub enum Deeplink {
+    Asset { asset_id: AssetId },
+    Perpetuals,
+    Rewards { code: Option<String> },
+}
+
+#[uniffi::export]
+pub fn deeplink_build_url(deeplink: Deeplink) -> String {
+    deeplink.to_url()
+}
+
+#[uniffi::export]
+pub fn deeplink_build_gem_url(deeplink: Deeplink) -> String {
+    deeplink.to_gem_url()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_deeplink() {
+        let rewards = Deeplink::Rewards {
+            code: Some("gemcoder".to_string()),
+        };
+        assert_eq!(deeplink_build_url(rewards), "https://gemwallet.com/rewards?code=gemcoder");
+        assert_eq!(deeplink_build_gem_url(Deeplink::Perpetuals), "gem://perpetuals");
+    }
+}