test(contract): unit-cover VerifierNotConfigured and revert_dstack_store

Adds in-process coverage the reviewer asked for on the async attestation
flow:
- submit_participant_info rejects a Dstack submission with
  VerifierNotConfigured when no verifier is voted in (fails before the
  yield)
- TeeState::revert_dstack_store restores the displaced entry on an update
  and removes a newly-inserted one

The VerificationAlreadyPending / pending-insert and InsufficientDeposit
invariants aren't unit-testable: near_sdk's mock VM does not support
promise_yield_create and does not simulate storage_usage() deltas. Those
paths are exercised by the sandbox tee_verifier tests.

Author: pbeza

crates/contract/src/tee/tee_state.rs

@@ -1501,6 +1501,75 @@ mod tests {
         assert_eq!(stored.node_id, rotated_node);
     }
 
+    #[test]
+    fn revert_dstack_store__restores_the_displaced_entry_on_update() {
+        // Given: `alice` has an attestation, then updates it — the second insertion
+        // returns the displaced original wrapped in `UpdatedExistingParticipant`.
+        const TEE_UPGRADE_DURATION: Duration = Duration::from_secs(10_000);
+        let mut tee_state = TeeState::default();
+        let tls_public_key = bogus_ed25519_public_key();
+        let original_node = NodeId {
+            account_id: "alice.near".parse().unwrap(),
+            tls_public_key: tls_public_key.clone(),
+            account_public_key: bogus_ed25519_public_key(),
+        };
+        tee_state
+            .add_mock_participant(
+                original_node.clone(),
+                MockAttestation::Valid,
+                TEE_UPGRADE_DURATION,
+            )
+            .expect("initial insertion should succeed");
+        let updated_node = NodeId {
+            account_id: "alice.near".parse().unwrap(),
+            tls_public_key: tls_public_key.clone(),
+            account_public_key: bogus_ed25519_public_key(),
+        };
+        let insertion = tee_state
+            .add_mock_participant(updated_node, MockAttestation::Valid, TEE_UPGRADE_DURATION)
+            .expect("update should succeed");
+        assert_matches!(
+            insertion,
+            ParticipantInsertion::UpdatedExistingParticipant(_)
+        );
+
+        // When: the store is reverted.
+        tee_state.revert_dstack_store(&tls_public_key, insertion);
+
+        // Then: the original (displaced) entry is back in place.
+        let stored = tee_state
+            .stored_attestations
+            .get(&tls_public_key)
+            .expect("original entry must be restored");
+        assert_eq!(stored.node_id, original_node);
+    }
+
+    #[test]
+    fn revert_dstack_store__removes_the_newly_inserted_entry() {
+        // Given: a brand-new attestation for `alice` (no prior entry displaced).
+        const TEE_UPGRADE_DURATION: Duration = Duration::from_secs(10_000);
+        let mut tee_state = TeeState::default();
+        let tls_public_key = bogus_ed25519_public_key();
+        let node = NodeId {
+            account_id: "alice.near".parse().unwrap(),
+            tls_public_key: tls_public_key.clone(),
+            account_public_key: bogus_ed25519_public_key(),
+        };
+        let insertion = tee_state
+            .add_mock_participant(node, MockAttestation::Valid, TEE_UPGRADE_DURATION)
+            .expect("insertion should succeed");
+        assert_matches!(insertion, ParticipantInsertion::NewlyInsertedParticipant);
+
+        // When: the store is reverted.
+        tee_state.revert_dstack_store(&tls_public_key, insertion);
+
+        // Then: the entry is gone.
+        assert!(
+            tee_state.stored_attestations.get(&tls_public_key).is_none(),
+            "newly inserted entry must be removed on revert"
+        );
+    }
+
     #[test]
     fn add_participant_rejects_invalid_attestations() {
         let mut tee_state = TeeState::default();

crates/contract/tests/inprocess/attestation_submission.rs

@@ -3,7 +3,7 @@
 use mpc_contract::{
     MpcContract,
     crypto_shared::types::PublicKeyExtended,
-    errors::Error,
+    errors::{Error, TeeError},
     primitives::{
         key_state::{AttemptId, EpochId, KeyForDomain, Keyset},
         participants::{ParticipantId, ParticipantInfo},
@@ -24,6 +24,7 @@ use near_account_id::AccountId;
 use near_sdk::{NearToken, VMContext, test_utils::VMContextBuilder, testing_env};
 use rstest::rstest;
 use std::{str::FromStr, time::Duration};
+use test_utils::attestation::mock_dto_dstack_attestation;
 
 const SECOND: Duration = Duration::from_secs(1);
 const NANOS_IN_SECOND: u64 = SECOND.as_nanos() as u64;
@@ -353,6 +354,25 @@ fn submit_participant_info__should_reject_overwrite_from_other_account() {
     assert_eq!(stored_before, stored_after);
 }
 
+/// **Test that a `Dstack` submission is rejected when no verifier is configured.** The
+/// async path has nowhere to offload DCAP verification, so it must fail up front (before
+/// registering a yield) rather than leave a submission that can never resolve.
+#[test]
+fn submit_participant_info__should_reject_dstack_when_verifier_not_configured() {
+    // Given: a running contract with no TEE verifier voted in.
+    let mut setup = TestSetupBuilder::new().build();
+    let node = setup.get_participant_node_ids()[0].clone();
+
+    // When: that participant submits a Dstack attestation.
+    let result = setup.try_submit_attestation_for_node(&node, mock_dto_dstack_attestation());
+
+    // Then: it is rejected with `VerifierNotConfigured`.
+    assert_matches!(
+        &result,
+        Err(Error::TeeError(TeeError::VerifierNotConfigured))
+    );
+}
+
 /// **Test that `clean_tee_status()` is vote-only** — attestations for non-participants
 /// remain in `stored_attestations` after the call. Attestation pruning is handled by the
 /// separate `clean_invalid_attestations` endpoint.