fix(node): recognize expiry-stamped mock attestations across upgrade

With the contract now stamping an expiry on accepted mocks, a submitted
Mock::Valid is stored as WithConstraints{expiry}. The node confirmed mock
submissions by identity (stored == submitted), which would never match the
re-stamped form, so a node on the new contract would treat every mock
submit as not-landed and retry until it errored.

Assuming node-is-upgraded-before-contract, the upgraded node must work
with both contract versions:
- submitted_attestation_landed: confirm an expiry-carrying mock via the
  same expiry-changed heuristic used for Dstack; fall back to identity for
  the bare Valid form stored by older contracts.
- read_stored_attestation_expiry (renamed from _dstack): also return the
  mock expiry so the pre-submit baseline is accurate.
- add VerifiedAttestation/MockAttestation::expiry_timestamp_seconds helpers.

Author: barakeinav1

crates/near-mpc-contract-interface/src/types/attestation.rs

@@ -75,6 +75,18 @@ pub enum VerifiedAttestation {
     Mock(MockAttestation),
 }
 
+impl VerifiedAttestation {
+    /// The stored expiry timestamp, if the attestation carries one. `Dstack`
+    /// entries always do; a `Mock` entry does only when it was stamped with an
+    /// expiry — contracts predating #3293 store `Mock::Valid` without one.
+    pub fn expiry_timestamp_seconds(&self) -> Option<u64> {
+        match self {
+            VerifiedAttestation::Dstack(attestation) => Some(attestation.expiry_timestamp_seconds),
+            VerifiedAttestation::Mock(attestation) => attestation.expiry_timestamp_seconds(),
+        }
+    }
+}
+
 #[derive(
     Clone,
     Debug,
@@ -184,6 +196,20 @@ pub enum MockAttestation {
     },
 }
 
+impl MockAttestation {
+    /// The configured expiry timestamp, if any. `Valid` and `Invalid` never
+    /// carry one.
+    pub fn expiry_timestamp_seconds(&self) -> Option<u64> {
+        match self {
+            MockAttestation::WithConstraints {
+                expiry_timestamp_seconds,
+                ..
+            } => *expiry_timestamp_seconds,
+            MockAttestation::Valid | MockAttestation::Invalid => None,
+        }
+    }
+}
+
 // TODO(#3494): superseded by `tee_verifier_interface::Collateral`; remove
 // this serde-carrying copy once `mpc-contract` consumes the Borsh mirrors.
 #[derive(

crates/node/src/indexer.rs

@@ -427,9 +427,9 @@ impl ReadSupportedForeignChain for RealForeignChainPolicyReader {
 }
 
 pub(crate) trait ReadAttestationExpiry: Send + Sync {
-    /// The Dstack attestation expiry currently stored for `tls_public_key`, or `None` if none is
-    /// stored.
-    fn read_stored_dstack_expiry<'a>(
+    /// The attestation expiry currently stored for `tls_public_key`, or `None` if none is stored or
+    /// the stored attestation carries no expiry (a mock stored by a contract predating #3293).
+    fn read_stored_attestation_expiry<'a>(
         &'a self,
         tls_public_key: &'a dtos::Ed25519PublicKey,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = anyhow::Result<Option<u64>>> + Send + 'a>>;
@@ -446,7 +446,7 @@ impl RealAttestationExpiryReader {
 }
 
 impl ReadAttestationExpiry for RealAttestationExpiryReader {
-    fn read_stored_dstack_expiry<'a>(
+    fn read_stored_attestation_expiry<'a>(
         &'a self,
         tls_public_key: &'a dtos::Ed25519PublicKey,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = anyhow::Result<Option<u64>>> + Send + 'a>>
@@ -457,10 +457,7 @@ impl ReadAttestationExpiry for RealAttestationExpiryReader {
                 .view_client
                 .get_participant_attestation(&self.indexer_state.mpc_contract_id, tls_public_key)
                 .await?;
-            Ok(match stored {
-                Some(dtos::VerifiedAttestation::Dstack(a)) => Some(a.expiry_timestamp_seconds),
-                _ => None,
-            })
+            Ok(stored.and_then(|attestation| attestation.expiry_timestamp_seconds()))
         })
     }
 }

crates/node/src/indexer/fake.rs

@@ -63,7 +63,7 @@ pub struct FakeReadSupportedForeignChain {
 struct FakeAttestationExpiryReader;
 
 impl ReadAttestationExpiry for FakeAttestationExpiryReader {
-    fn read_stored_dstack_expiry<'a>(
+    fn read_stored_attestation_expiry<'a>(
         &'a self,
         _tls_public_key: &'a near_mpc_contract_interface::types::Ed25519PublicKey,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = anyhow::Result<Option<u64>>> + Send + 'a>>

crates/node/src/indexer/tx_sender.rs

@@ -190,11 +190,13 @@ fn attestation_expiry_changed(pre_submit_expiry: Option<u64>, stored_expiry: u64
 
 /// Whether the attestation we submitted is now the one stored on chain.
 ///
-/// Mock is matched by identity. A Dstack entry keeps no stored per-submission identity, so it is
-/// confirmed via [`attestation_expiry_changed`]: an accepted submit re-stamps the entry's expiry
-/// (to the submit block time plus
+/// An entry that carries an expiry keeps no stored per-submission identity, so it is confirmed via
+/// [`attestation_expiry_changed`]: an accepted submit re-stamps the entry's expiry (to the submit
+/// block time plus
 /// [`DEFAULT_EXPIRATION_DURATION_SECONDS`](mpc_attestation::attestation::DEFAULT_EXPIRATION_DURATION_SECONDS)),
-/// and only the owning account may rewrite it, so a changed expiry means our submit landed.
+/// and only the owning account may rewrite it, so a changed expiry means our submit landed. This
+/// covers every Dstack entry, and mock entries stored by contracts that stamp expiries (#3293).
+/// A mock stored by an older contract carries no expiry and is matched by identity instead.
 // TODO(#1639): match a certificate-derived identity instead of this expiry heuristic.
 fn submitted_attestation_landed(
     pre_submit_expiry: Option<u64>,
@@ -205,7 +207,12 @@ fn submitted_attestation_landed(
         (VerifiedAttestation::Dstack(stored), Attestation::Dstack(_)) => {
             attestation_expiry_changed(pre_submit_expiry, stored.expiry_timestamp_seconds)
         }
-        (VerifiedAttestation::Mock(stored), Attestation::Mock(submitted)) => stored == submitted,
+        (VerifiedAttestation::Mock(stored), Attestation::Mock(submitted)) => {
+            match stored.expiry_timestamp_seconds() {
+                Some(expiry) => attestation_expiry_changed(pre_submit_expiry, expiry),
+                None => stored == submitted,
+            }
+        }
         _ => false,
     }
 }
@@ -283,10 +290,7 @@ async fn observe_tx_result(
                 return Ok(TransactionStatus::NotExecuted);
             };
 
-            let stored_expiry = match &stored_attestation {
-                VerifiedAttestation::Dstack(stored) => Some(stored.expiry_timestamp_seconds),
-                VerifiedAttestation::Mock(_) => None,
-            };
+            let stored_expiry = stored_attestation.expiry_timestamp_seconds();
             let attestation_landed = submitted_attestation_landed(
                 *pre_submit_expiry,
                 &stored_attestation,
@@ -476,4 +480,43 @@ mod tests {
         // Then
         assert!(!landed);
     }
+
+    fn mock_with_expiry(expiry_timestamp_seconds: u64) -> MockAttestation {
+        MockAttestation::WithConstraints {
+            mpc_docker_image_hash: None,
+            launcher_docker_compose_hash: None,
+            expiry_timestamp_seconds: Some(expiry_timestamp_seconds),
+            expected_measurements: None,
+        }
+    }
+
+    #[test]
+    #[expect(non_snake_case)]
+    fn submitted_attestation_landed__should_confirm_mock_with_changed_expiry() {
+        // Given: a contract that stamps expiries on mocks (#3293) re-stamped our
+        // submitted `Mock::Valid` as an expiring `WithConstraints`, changing the expiry.
+        let stored = VerifiedAttestation::Mock(mock_with_expiry(200));
+        let submitted = Attestation::Mock(MockAttestation::Valid);
+
+        // When
+        let landed = submitted_attestation_landed(Some(100), &stored, &submitted);
+
+        // Then: the changed expiry confirms our submit landed.
+        assert!(landed);
+    }
+
+    #[test]
+    #[expect(non_snake_case)]
+    fn submitted_attestation_landed__should_reject_mock_with_unchanged_expiry() {
+        // Given: an expiry-carrying mock whose stored expiry is unchanged since before
+        // our submit (our resubmit did not land).
+        let stored = VerifiedAttestation::Mock(mock_with_expiry(200));
+        let submitted = Attestation::Mock(MockAttestation::Valid);
+
+        // When
+        let landed = submitted_attestation_landed(Some(200), &stored, &submitted);
+
+        // Then: no change means the submit is treated as not executed.
+        assert!(!landed);
+    }
 }

crates/node/src/tee/remote_attestation.rs

@@ -208,7 +208,7 @@ pub async fn periodic_attestation_submission<T: TransactionSender + Clone, I: Ti
         let allowed_launcher_compose_hashes_in_contract =
             allowed_launcher_compose_hashes_in_contract.borrow().clone();
         let pre_submit_expiry = match attestation_reader
-            .read_stored_dstack_expiry(&tls_public_key)
+            .read_stored_attestation_expiry(&tls_public_key)
             .await
         {
             Ok(baseline) => baseline, // None just means nothing stored yet (e.g. first submit)
@@ -333,7 +333,7 @@ pub async fn monitor_attestation_removal<T: TransactionSender + Clone>(
             let allowed_launcher_compose_hashes_in_contract =
                 allowed_launcher_compose_hashes_in_contract.borrow().clone();
             let pre_submit_expiry = match attestation_reader
-                .read_stored_dstack_expiry(&tls_public_key)
+                .read_stored_attestation_expiry(&tls_public_key)
                 .await
             {
                 Ok(baseline) => baseline, // None just means nothing stored yet (e.g. first submit)
@@ -409,7 +409,7 @@ mod tests {
     struct StubAttestationExpiryReader;
 
     impl crate::indexer::ReadAttestationExpiry for StubAttestationExpiryReader {
-        fn read_stored_dstack_expiry<'a>(
+        fn read_stored_attestation_expiry<'a>(
             &'a self,
             _tls_public_key: &'a Ed25519PublicKey,
         ) -> std::pin::Pin<
@@ -422,7 +422,7 @@ mod tests {
     struct FailingAttestationExpiryReader;
 
     impl crate::indexer::ReadAttestationExpiry for FailingAttestationExpiryReader {
-        fn read_stored_dstack_expiry<'a>(
+        fn read_stored_attestation_expiry<'a>(
             &'a self,
             _tls_public_key: &'a Ed25519PublicKey,
         ) -> std::pin::Pin<