refactor: replace tuple with AttestedContract struct

Replace the tuple (ContractInstanceId, ClientId, Instant) with a
properly named struct to improve code readability and maintainability.

The AttestedContract struct provides:
- Named fields instead of positional tuple access
- Self-documenting code
- Easier future extensibility

Co-authored-by: nacho.d.g <iduartgomez@users.noreply.github.com>

Author: github-actions[bot]

crates/core/src/client_events/websocket.rs

@@ -298,9 +298,9 @@ async fn websocket_commands(
             }
 
             if let Some(entry) = attested_contracts.get(token) {
-                let (cid, _, _) = entry.value();
-                tracing::trace!(?token, ?cid, "Found token in attested_contracts map");
-                Some((token.clone(), *cid))
+                let attested = entry.value();
+                tracing::trace!(?token, contract_id = ?attested.contract_id, "Found token in attested_contracts map");
+                Some((token.clone(), attested.contract_id))
             } else {
                 tracing::warn!(?token, "Auth token not found in attested_contracts map");
                 None

crates/core/src/node/mod.rs

@@ -1335,7 +1335,7 @@ pub async fn run_local_node(
                 let attested_contract = token.and_then(|token| {
                     gw.attested_contracts
                         .get(&token)
-                        .map(|entry| entry.value().0)
+                        .map(|entry| entry.value().contract_id)
                 });
                 let op_name = match op {
                     DelegateRequest::RegisterDelegate { .. } => "RegisterDelegate",

crates/core/src/server/http_gateway.rs

@@ -34,9 +34,30 @@ impl std::ops::Deref for HttpGatewayRequest {
     }
 }
 
-/// Maps authentication tokens to contract instances, client IDs, and last access time.
-/// The Instant tracks when the token was last used to enable time-based expiration.
-pub type AttestedContractMap = Arc<DashMap<AuthToken, (ContractInstanceId, ClientId, Instant)>>;
+/// Represents an attested contract entry with metadata for token expiration.
+#[derive(Clone, Debug)]
+pub struct AttestedContract {
+    /// The contract instance ID
+    pub contract_id: ContractInstanceId,
+    /// The client ID associated with this token
+    pub client_id: ClientId,
+    /// Timestamp of when the token was last accessed (for expiration tracking)
+    pub last_accessed: Instant,
+}
+
+impl AttestedContract {
+    /// Create a new attested contract entry
+    pub fn new(contract_id: ContractInstanceId, client_id: ClientId) -> Self {
+        Self {
+            contract_id,
+            client_id,
+            last_accessed: Instant::now(),
+        }
+    }
+}
+
+/// Maps authentication tokens to attested contract metadata.
+pub type AttestedContractMap = Arc<DashMap<AuthToken, AttestedContract>>;
 
 /// A gateway to access and interact with contracts through an HTTP interface.
 pub(crate) struct HttpGateway {
@@ -86,9 +107,9 @@ impl ClientEventsProxy for HttpGateway {
                             .send(HostCallbackResult::NewId { id: cli_id })
                             .map_err(|_e| ErrorKind::NodeUnavailable)?;
                         if let Some((assigned_token, contract)) = assigned_token {
-                            let now = Instant::now();
+                            let attested = AttestedContract::new(contract, cli_id);
                             self.attested_contracts
-                                .insert(assigned_token.clone(), (contract, cli_id, now));
+                                .insert(assigned_token.clone(), attested);
                             tracing::debug!(
                                 ?assigned_token,
                                 ?contract,

crates/core/src/server/mod.rs

@@ -155,8 +155,8 @@ pub mod local_node {
                         .attested_contracts
                         .iter()
                         .find_map(|entry| {
-                            let (k, (_, eid, _)) = entry.pair();
-                            (eid == &id).then(|| k.clone())
+                            let (k, attested) = entry.pair();
+                            (attested.client_id == id).then(|| k.clone())
                         })
                     {
                         gw.attested_contracts.remove(&rm_token);
@@ -250,15 +250,15 @@ fn spawn_token_cleanup_task(attested_contracts: AttestedContractMap) {
             let initial_count = attested_contracts.len();
 
             // Remove tokens that haven't been accessed in TOKEN_TTL
-            attested_contracts.retain(|token, (contract_id, client_id, last_used)| {
-                let elapsed = now.duration_since(*last_used);
+            attested_contracts.retain(|token, attested| {
+                let elapsed = now.duration_since(attested.last_accessed);
                 let should_keep = elapsed < TOKEN_TTL;
 
                 if !should_keep {
                     tracing::info!(
                         ?token,
-                        ?contract_id,
-                        ?client_id,
+                        contract_id = ?attested.contract_id,
+                        client_id = ?attested.client_id,
                         elapsed_hours = elapsed.as_secs() / 3600,
                         "Removing expired authentication token"
                     );