Salted nonces

core/src/accounts.rs

@@ -4,7 +4,7 @@ use near_sdk::{AccountIdRef, near};
 use serde_with::serde_as;
 use std::borrow::Cow;
 
-use crate::Nonce;
+use crate::{Nonce, Salt};
 
 #[must_use = "make sure to `.emit()` this event"]
 #[near(serializers = [json])]
@@ -63,3 +63,11 @@ impl NonceEvent {
         Self { nonce }
     }
 }
+
+#[must_use = "make sure to `.emit()` this event"]
+#[near(serializers = [json])]
+#[derive(Debug, Clone)]
+pub struct SaltRotationEvent {
+    pub old_salt: Salt,
+    pub new_salt: Salt,
+}

core/src/engine/mod.rs

@@ -6,7 +6,7 @@ pub use self::{inspector::*, state::*};
 use defuse_crypto::{Payload, SignedPayload};
 
 use crate::{
-    DefuseError, ExpirableNonce, Result,
+    DefuseError, Result,
     intents::{DefuseIntents, ExecutableIntent},
     payload::{DefusePayload, ExtractDefusePayload, multi::MultiPayload},
 };
@@ -64,10 +64,6 @@ where
 
         self.inspector.on_deadline(deadline);
 
-        if ExpirableNonce::maybe_from(nonce).is_some_and(|n| deadline > n.deadline) {
-            return Err(DefuseError::DeadlineGreaterThanNonce);
-        }
-
         // make sure message is still valid
         if deadline.has_expired() {
             return Err(DefuseError::DeadlineExpired);
@@ -79,6 +75,7 @@ where
         }
 
         // commit nonce
+        self.state.verify_intent_nonce(nonce, deadline)?;
         self.state.commit_nonce(signer_id.clone(), nonce)?;
 
         intents.execute_intent(&signer_id, self, hash)?;

core/src/engine/state/cached.rs

@@ -1,5 +1,5 @@
 use crate::{
-    DefuseError, Nonce, Nonces, Result,
+    Deadline, DefuseError, Nonce, Nonces, Result,
     amounts::Amounts,
     fees::Pips,
     intents::{
@@ -119,6 +119,14 @@ where
             .is_some_and(|a| a.auth_by_predecessor_id_toggled);
         was_enabled ^ toggled
     }
+
+    fn verify_intent_nonce(&self, nonce: Nonce, intent_deadline: Deadline) -> Result<()> {
+        self.view.verify_intent_nonce(nonce, intent_deadline)
+    }
+
+    fn is_nonce_cleanable(&self, nonce: Nonce) -> Result<bool> {
+        self.view.is_nonce_cleanable(nonce)
+    }
 }
 
 impl<W> State for CachedState<W>

core/src/engine/state/deltas.rs

@@ -1,5 +1,5 @@
 use crate::{
-    DefuseError, Nonce, Result,
+    Deadline, DefuseError, Nonce, Result,
     amounts::Amounts,
     fees::Pips,
     intents::{
@@ -96,6 +96,16 @@ where
     fn is_auth_by_predecessor_id_enabled(&self, account_id: &AccountIdRef) -> bool {
         self.state.is_auth_by_predecessor_id_enabled(account_id)
     }
+
+    #[inline]
+    fn verify_intent_nonce(&self, nonce: Nonce, intent_deadline: Deadline) -> Result<()> {
+        self.state.verify_intent_nonce(nonce, intent_deadline)
+    }
+
+    #[inline]
+    fn is_nonce_cleanable(&self, nonce: Nonce) -> Result<bool> {
+        self.state.is_nonce_cleanable(nonce)
+    }
 }
 
 impl<S> State for Deltas<S>

core/src/engine/state/mod.rs

@@ -2,7 +2,7 @@ pub mod cached;
 pub mod deltas;
 
 use crate::{
-    Nonce, Result,
+    Deadline, Nonce, Result,
     fees::Pips,
     intents::{
         auth::AuthCall,
@@ -42,6 +42,12 @@ pub trait StateView {
     /// Returns whether authentication by `PREDECESSOR_ID` is enabled.
     fn is_auth_by_predecessor_id_enabled(&self, account_id: &AccountIdRef) -> bool;
 
+    /// Verifies whether the nonce can be committed
+    fn verify_intent_nonce(&self, nonce: Nonce, intent_deadline: Deadline) -> Result<()>;
+
+    /// Returns whether the nonce can be cleaned up
+    fn is_nonce_cleanable(&self, nonce: Nonce) -> Result<bool>;
+
     #[inline]
     fn cached(self) -> CachedState<Self>
     where

core/src/error.rs

@@ -55,6 +55,9 @@ pub enum DefuseError {
     #[error("nonce was already expired")]
     NonceExpired,
 
+    #[error("invalid nonce")]
+    InvalidNonce,
+
     #[error("public key '{1}' already exists for account '{0}'")]
     PublicKeyExists(AccountId, PublicKey),
 
@@ -66,4 +69,7 @@ pub enum DefuseError {
 
     #[error("wrong verifying_contract")]
     WrongVerifyingContract,
+
+    #[error("invalid salt")]
+    InvalidSalt,
 }

core/src/events.rs

@@ -4,7 +4,7 @@ use derive_more::derive::From;
 use near_sdk::{near, serde::Deserialize};
 
 use crate::{
-    accounts::{AccountEvent, NonceEvent, PublicKeyEvent},
+    accounts::{AccountEvent, NonceEvent, PublicKeyEvent, SaltRotationEvent},
     fees::{FeeChangedEvent, FeeCollectorChangedEvent},
     intents::{
         IntentEvent,
@@ -30,6 +30,10 @@ pub enum DefuseEvent<'a> {
     #[event_version("0.3.0")]
     FeeCollectorChanged(FeeCollectorChangedEvent<'a>),
 
+    // TODO: which version should this be?
+    #[event_version("0.1.0")]
+    SaltRotationEvent(SaltRotationEvent),
+
     #[event_version("0.3.0")]
     Transfer(Cow<'a, [IntentEvent<AccountEvent<'a, Cow<'a, Transfer>>>]>),
 

core/src/nonce/expirable.rs

@@ -0,0 +1,61 @@
+use defuse_borsh_utils::adapters::{As, TimestampNanoSeconds};
+use near_sdk::borsh::{BorshDeserialize, BorshSerialize};
+
+use crate::Deadline;
+
+/// Expirable nonces contain deadline which is 8 bytes of timestamp in nanoseconds
+#[derive(Clone, Debug, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
+#[borsh(crate = "::near_sdk::borsh")]
+pub struct ExpirableNonce<T>
+where
+    T: BorshSerialize + BorshDeserialize,
+{
+    #[borsh(
+        serialize_with = "As::<TimestampNanoSeconds>::serialize",
+        deserialize_with = "As::<TimestampNanoSeconds>::deserialize"
+    )]
+    pub deadline: Deadline,
+    pub nonce: T,
+}
+
+impl<T> ExpirableNonce<T>
+where
+    T: BorshSerialize + BorshDeserialize,
+{
+    pub const fn new(deadline: Deadline, nonce: T) -> Self {
+        Self { deadline, nonce }
+    }
+
+    #[inline]
+    pub fn has_expired(&self) -> bool {
+        self.deadline.has_expired()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use chrono::{Days, Utc};
+    use defuse_test_utils::random::random_bytes;
+    use rstest::rstest;
+
+    #[rstest]
+    fn expirable_test(random_bytes: Vec<u8>) {
+        let current_timestamp = Utc::now();
+        let mut u = arbitrary::Unstructured::new(&random_bytes);
+        let nonce: [u8; 24] = u.arbitrary().unwrap();
+
+        let expired = ExpirableNonce::new(
+            Deadline::new(current_timestamp.checked_sub_days(Days::new(1)).unwrap()),
+            nonce,
+        );
+        assert!(expired.has_expired());
+
+        let not_expired = ExpirableNonce::new(
+            Deadline::new(current_timestamp.checked_add_days(Days::new(1)).unwrap()),
+            nonce,
+        );
+        assert!(!not_expired.has_expired());
+    }
+}