[ABW-3915] Expiration errors (#258)

* get expiration status * add new Error types * wip * updates to use u64 instead of Timestamp * bump Sargon * lint * Add Siwft Tests * Add extension for status --------- Co-authored-by: micbakos-rdx <[email protected]>
radixdlt · Nov 8, 2024 · 456272e · 456272e
1 parent 82af570
commit 456272e
Show file tree

Hide file tree

Showing 23 changed files with 322 additions and 33 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/...Connect/WalletInteraction/DappToWalletInteractionSubintentExpiration+Wrap+Functions.swift b/...Connect/WalletInteraction/DappToWalletInteractionSubintentExpiration+Wrap+Functions.swift
@@ -0,0 +1,8 @@
+import Foundation
+import SargonUniFFI
+
+extension DappToWalletInteractionSubintentExpiration {
+	public func getStatus() -> DappToWalletInteractionSubintentExpirationStatus {
+		getSubintentExpirationStatus(expiration: self)
+	}
+}
diff --git a/...nnect/WalletInteraction/DappToWalletInteractionSubintentExpireAtTime+Wrap+Functions.swift b/...nnect/WalletInteraction/DappToWalletInteractionSubintentExpireAtTime+Wrap+Functions.swift
@@ -0,0 +1,8 @@
+import Foundation
+import SargonUniFFI
+
+extension DappToWalletInteractionSubintentExpireAtTime {
+	public var date: Date {
+		.init(timeIntervalSince1970: TimeInterval(unixTimestampSeconds))
+	}
+}
diff --git a/...ases/RadixConnect/WalletInteraction/DappToWalletInteractionSubintentExpirationTests.swift b/...ases/RadixConnect/WalletInteraction/DappToWalletInteractionSubintentExpirationTests.swift
@@ -0,0 +1,22 @@
+import Foundation
+import SargonUniFFI
+import XCTest
+
+final class DappToWalletInteractionSubintentExpirationTests: TestCase {
+	typealias SUT = DappToWalletInteractionSubintentExpiration
+
+	func testGetStatus() throws {
+		let afterDelay = SUT.afterDelay(.init(expireAfterSeconds: 100))
+		XCTAssertEqual(afterDelay.getStatus(), .valid)
+
+		let atTimeExpired = SUT.atTime(.init(unixTimestampSeconds: 0))
+		XCTAssertEqual(atTimeExpired.getStatus(), .expired)
+
+		let now = UInt64(Date.now.timeIntervalSince1970)
+		let atTimeCloseToExpiration = SUT.atTime(.init(unixTimestampSeconds: now + 15))
+		XCTAssertEqual(atTimeCloseToExpiration.getStatus(), .expirationTooClose)
+
+		let atTimeValid = SUT.atTime(.init(unixTimestampSeconds: now + 60))
+		XCTAssertEqual(atTimeValid.getStatus(), .valid)
+	}
+}
diff --git a/...es/RadixConnect/WalletInteraction/DappToWalletInteractionSubintentExpireAtTimeTests.swift b/...es/RadixConnect/WalletInteraction/DappToWalletInteractionSubintentExpireAtTimeTests.swift
@@ -0,0 +1,18 @@
+import Foundation
+import SargonUniFFI
+import XCTest
+
+final class DappToWalletInteractionSubintentExpireAtTimeTests: TestCase {
+	typealias SUT = DappToWalletInteractionSubintentExpireAtTime
+
+	func testDate() throws {
+		var sut = SUT.init(unixTimestampSeconds: 0)
+		XCTAssertEqual(sut.date, Date(timeIntervalSince1970: 0))
+
+		sut = .init(unixTimestampSeconds: 500)
+		XCTAssertEqual(sut.date, Date(timeIntervalSince1970: 500))
+
+		sut = .init(unixTimestampSeconds: 1000)
+		XCTAssertEqual(sut.date.timeIntervalSince1970, 1000)
+	}
+}
diff --git a/crates/sargon-uniffi/Cargo.toml b/crates/sargon-uniffi/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "sargon-uniffi"
 # Don't forget to update version in crates/sargon/Cargo.toml
-version = "1.1.47"
+version = "1.1.48"
 edition = "2021"
 build = "build.rs"
 

diff --git a/...llet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/at_time.rs b/...llet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/at_time.rs
@@ -5,5 +5,5 @@ use sargon::DappToWalletInteractionSubintentExpireAtTime as InternalDappToWallet
 #[derive(Clone, PartialEq, InternalConversion, uniffi::Record)]
 pub struct DappToWalletInteractionSubintentExpireAtTime {
     /// The unix timestamp in seconds when the subintent expires.
-    pub unix_timestamp_seconds: Timestamp,
+    pub unix_timestamp_seconds: u64,
 }
diff --git a/...t_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/expiration.rs b/...t_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/expiration.rs
@@ -22,3 +22,10 @@ pub enum DappToWalletInteractionSubintentExpiration {
     /// 100 XRD over 2 USDT will succeed. Otherwise, it would fail.
     AfterDelay(DappToWalletInteractionSubintentExpireAfterDelay),
 }
+
+#[uniffi::export]
+pub fn get_subintent_expiration_status(
+    expiration: &DappToWalletInteractionSubintentExpiration,
+) -> DappToWalletInteractionSubintentExpirationStatus {
+    expiration.into_internal().get_status().into()
+}
diff --git a/...p_wallet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/mod.rs b/...p_wallet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/mod.rs
@@ -1,7 +1,9 @@
 mod after_delay;
 mod at_time;
 mod expiration;
+mod status;
 
 pub use after_delay::*;
 pub use at_time::*;
 pub use expiration::*;
+pub use status::*;
diff --git a/...allet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/status.rs b/...allet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/status.rs
@@ -0,0 +1,19 @@
+use crate::prelude::*;
+use sargon::DappToWalletInteractionSubintentExpirationStatus as InternalDappToWalletInteractionSubintentExpirationStatus;
+
+/// An enum that represents the expiration status of a subintent at a given time.
+///
+/// Useful for determining if a subintent is still valid at the moment the Host apps
+/// receive the corresponding request.
+#[derive(Clone, PartialEq, InternalConversion, uniffi::Enum)]
+pub enum DappToWalletInteractionSubintentExpirationStatus {
+    /// The subintent hasn't expired yet
+    Valid,
+
+    /// The subintent is too close to its expiration. Although it hasn't expired yet, the Host apps
+    /// shouldn't allow the user dealing with it.
+    ExpirationTooClose,
+
+    /// The subintent has already expired.
+    Expired,
+}
diff --git a/.../wallet_interaction/dapp_wallet_interaction/wallet_to_dapp/failure_response/error_type.rs b/.../wallet_interaction/dapp_wallet_interaction/wallet_to_dapp/failure_response/error_type.rs
@@ -25,4 +25,6 @@ pub enum DappWalletInteractionErrorType {
     IncompatibleVersion,
     FailedToSignAuthChallenge,
     InvalidPersonaOrAccounts,
+    ExpiredSubintent,
+    SubintentExpirationTooClose,
 }
diff --git a/crates/sargon/Cargo.toml b/crates/sargon/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "sargon"
 # Don't forget to update version in crates/sargon-uniffi/Cargo.toml
-version = "1.1.47"
+version = "1.1.48"
 edition = "2021"
 build = "build.rs"
 

diff --git a/crates/sargon/fixtures/vector/wallet_interactions_dapp_to_wallet.json b/crates/sargon/fixtures/vector/wallet_interactions_dapp_to_wallet.json
@@ -203,7 +203,7 @@
         "message": "message",
         "expiration": {
           "discriminator": "expireAtTime",
-          "unixTimestampSeconds": "2023-09-11T16:05:56.000Z"
+          "unixTimestampSeconds": 1730999831257
         }
       }
     },

diff --git a/crates/sargon/src/core/types/instant.rs b/crates/sargon/src/core/types/instant.rs
@@ -67,6 +67,7 @@ impl HasSampleValues for Instant {
 mod tests {
     use super::*;
     use crate::prelude::*;
+    use std::time::Duration;
 
     #[test]
     fn into_from_scrypto() {
@@ -111,12 +112,12 @@ mod tests {
 
     #[test]
     fn from_timestamp() {
-        let timestamp = Timestamp::now_utc();
-        let seconds_since_unix_epoch = timestamp
-            .duration_since(Timestamp::UNIX_EPOCH)
-            .as_seconds_f64() as i64;
+        let timestamp = Timestamp::UNIX_EPOCH;
         let instant = Instant::from(timestamp);
+        assert_eq!(instant.seconds_since_unix_epoch, 0);
 
-        assert_eq!(instant.seconds_since_unix_epoch, seconds_since_unix_epoch);
+        let timestamp = Timestamp::UNIX_EPOCH.add(Duration::from_secs(300));
+        let instant = Instant::from(timestamp);
+        assert_eq!(instant.seconds_since_unix_epoch, 300);
     }
 }
diff --git a/...llet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/at_time.rs b/...llet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/at_time.rs
@@ -5,11 +5,11 @@ use crate::prelude::*;
 #[serde(rename_all = "camelCase")]
 pub struct DappToWalletInteractionSubintentExpireAtTime {
     /// The unix timestamp in seconds when the subintent expires.
-    pub unix_timestamp_seconds: Timestamp,
+    pub unix_timestamp_seconds: u64,
 }
 
-impl From<Timestamp> for DappToWalletInteractionSubintentExpireAtTime {
-    fn from(unix_timestamp_seconds: Timestamp) -> Self {
+impl From<u64> for DappToWalletInteractionSubintentExpireAtTime {
+    fn from(unix_timestamp_seconds: u64) -> Self {
         Self {
             unix_timestamp_seconds,
         }
@@ -19,13 +19,13 @@ impl From<Timestamp> for DappToWalletInteractionSubintentExpireAtTime {
 impl HasSampleValues for DappToWalletInteractionSubintentExpireAtTime {
     fn sample() -> Self {
         Self {
-            unix_timestamp_seconds: Timestamp::sample(),
+            unix_timestamp_seconds: 1730999831257,
         }
     }
 
     fn sample_other() -> Self {
         Self {
-            unix_timestamp_seconds: Timestamp::sample_other(),
+            unix_timestamp_seconds: 1730999850000,
         }
     }
 }
@@ -50,6 +50,6 @@ mod tests {
 
     #[test]
     fn from() {
-        assert_eq!(SUT::from(Timestamp::sample()), SUT::sample());
+        assert_eq!(SUT::from(1730999831257), SUT::sample());
     }
 }
diff --git a/...t_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/expiration.rs b/...t_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/expiration.rs
@@ -37,6 +37,37 @@ impl HasSampleValues for DappToWalletInteractionSubintentExpiration {
     }
 }
 
+impl DappToWalletInteractionSubintentExpiration {
+    pub fn get_status(
+        &self,
+    ) -> DappToWalletInteractionSubintentExpirationStatus {
+        match self {
+            Self::AtTime(expiration) => {
+                let now = seconds_since_unix_epoch();
+                let in_thirty_seconds = now + 30;
+                if expiration.unix_timestamp_seconds < now {
+                    DappToWalletInteractionSubintentExpirationStatus::Expired
+                } else if expiration.unix_timestamp_seconds < in_thirty_seconds
+                {
+                    DappToWalletInteractionSubintentExpirationStatus::ExpirationTooClose
+                } else {
+                    DappToWalletInteractionSubintentExpirationStatus::Valid
+                }
+            }
+            Self::AfterDelay(_) => {
+                DappToWalletInteractionSubintentExpirationStatus::Valid
+            }
+        }
+    }
+}
+
+// Returns the amounts of seconds since the Unix epoch.
+pub fn seconds_since_unix_epoch() -> u64 {
+    Timestamp::now_utc()
+        .duration_since(Timestamp::UNIX_EPOCH)
+        .as_seconds_f64() as u64
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -62,7 +93,7 @@ mod tests {
             r#"
         {
             "discriminator": "expireAtTime",
-            "unixTimestampSeconds": "2023-09-11T16:05:56.000Z"
+            "unixTimestampSeconds": 1730999831257
         }
         "#,
         );
@@ -77,4 +108,56 @@ mod tests {
         "#,
         );
     }
+
+    #[test]
+    fn status() {
+        let now = Timestamp::now_utc();
+
+        // AtTime which has already expired
+        let now = seconds_since_unix_epoch();
+        let past = now - 30;
+        let expiration = SUT::AtTime(past.into());
+        assert_eq!(
+            expiration.get_status(),
+            DappToWalletInteractionSubintentExpirationStatus::Expired
+        );
+
+        // AtTime which is less than 30 seconds from expiration
+        let in_ten_seconds = now + 10;
+        let expiration = DappToWalletInteractionSubintentExpiration::AtTime(
+            DappToWalletInteractionSubintentExpireAtTime {
+                unix_timestamp_seconds: in_ten_seconds,
+            },
+        );
+        assert_eq!(
+            expiration.get_status(),
+            DappToWalletInteractionSubintentExpirationStatus::ExpirationTooClose
+        );
+
+        // AtTime which is more than 30 seconds from expiration
+        let in_forty_seconds = now + 40;
+        let expiration = DappToWalletInteractionSubintentExpiration::AtTime(
+            DappToWalletInteractionSubintentExpireAtTime {
+                unix_timestamp_seconds: in_forty_seconds,
+            },
+        );
+        assert_eq!(
+            expiration.get_status(),
+            DappToWalletInteractionSubintentExpirationStatus::Valid
+        );
+
+        // AfterDelay is always Valid, either in 10 minutes
+        let expiration = SUT::AfterDelay(600.into());
+        assert_eq!(
+            expiration.get_status(),
+            DappToWalletInteractionSubintentExpirationStatus::Valid
+        );
+
+        // .. or in 15 seconds
+        let expiration = SUT::AfterDelay(15.into());
+        assert_eq!(
+            expiration.get_status(),
+            DappToWalletInteractionSubintentExpirationStatus::Valid
+        );
+    }
 }
diff --git a/...p_wallet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/mod.rs b/...p_wallet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/mod.rs
@@ -1,7 +1,9 @@
 mod after_delay;
 mod at_time;
 mod expiration;
+mod status;
 
 pub use after_delay::*;
 pub use at_time::*;
 pub use expiration::*;
+pub use status::*;
diff --git a/...allet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/status.rs b/...allet_interaction/dapp_to_wallet/interaction_items/pre_authorization/expiration/status.rs
@@ -0,0 +1,47 @@
+use crate::prelude::*;
+
+/// An enum that represents the expiration status of a subintent at a given time.
+///
+/// Useful for determining if a subintent is still valid at the moment the Host apps
+/// receive the corresponding request.
+#[derive(Debug, Clone, PartialEq)]
+pub enum DappToWalletInteractionSubintentExpirationStatus {
+    /// The subintent hasn't expired yet
+    Valid,
+
+    /// The subintent is too close to its expiration. Although it hasn't expired yet, the Host apps
+    /// shouldn't allow the user dealing with it.
+    ExpirationTooClose,
+
+    /// The subintent has already expired.
+    Expired,
+}
+
+impl HasSampleValues for DappToWalletInteractionSubintentExpirationStatus {
+    fn sample() -> Self {
+        Self::Valid
+    }
+
+    fn sample_other() -> Self {
+        Self::ExpirationTooClose
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[allow(clippy::upper_case_acronyms)]
+    type SUT = DappToWalletInteractionSubintentExpirationStatus;
+
+    #[test]
+    fn equality() {
+        assert_eq!(SUT::sample(), SUT::sample());
+        assert_eq!(SUT::sample_other(), SUT::sample_other());
+    }
+
+    #[test]
+    fn inequality() {
+        assert_ne!(SUT::sample(), SUT::sample_other());
+    }
+}
diff --git a/...n/dapp_wallet_interaction/dapp_to_wallet/interaction_items/pre_authorization/subintent.rs b/...n/dapp_wallet_interaction/dapp_to_wallet/interaction_items/pre_authorization/subintent.rs
@@ -82,7 +82,7 @@ mod tests {
                 "message" : "message",
                 "expiration": {
                     "discriminator": "expireAtTime",
-                    "unixTimestampSeconds": "2023-09-11T16:05:56.000Z"
+                    "unixTimestampSeconds": 1730999831257
                 }
             }
             "#,