newton-core 0.7.1

newton protocol core sdk
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use alloy::primitives::Address;
use moka::future::Cache;
use std::time::Duration;

/// Configuration for the policy contract cache.
#[derive(Clone, Debug)]
pub struct PolicyContractCacheConfig {
    /// TTL for version caches (changes only on proxy upgrade).
    pub version_ttl_secs: u64,
    /// Max entries for each version cache.
    pub version_max_capacity: u64,
}

impl Default for PolicyContractCacheConfig {
    fn default() -> Self {
        Self {
            version_ttl_secs: 600,
            version_max_capacity: 512,
        }
    }
}

/// Shared cache for on-chain policy contract reads: `(chain_id, policy_address)` -> version
/// string, TTL-based. Services share this via `Arc<PolicyContractCache>`.
pub struct PolicyContractCache {
    policy_version: Cache<(u64, Address), String>,
}

impl std::fmt::Debug for PolicyContractCache {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("PolicyContractCache")
            .field("policy_version_entry_count", &self.policy_version.entry_count())
            .finish()
    }
}

impl Default for PolicyContractCache {
    fn default() -> Self {
        Self::new(PolicyContractCacheConfig::default())
    }
}

impl PolicyContractCache {
    /// Create a new cache with the given configuration.
    pub fn new(config: PolicyContractCacheConfig) -> Self {
        Self {
            policy_version: Cache::builder()
                .time_to_live(Duration::from_secs(config.version_ttl_secs))
                .max_capacity(config.version_max_capacity)
                .build(),
        }
    }

    // -- Policy version cache (TTL-based) --

    /// Look up a cached policy implementation version.
    pub async fn get_policy_version(&self, chain_id: u64, policy_address: Address) -> Option<String> {
        self.policy_version.get(&(chain_id, policy_address)).await
    }

    /// Cache a policy implementation version.
    pub async fn insert_policy_version(&self, chain_id: u64, policy_address: Address, version: String) {
        self.policy_version.insert((chain_id, policy_address), version).await;
    }

    /// Get or populate a policy version, coalescing concurrent lookups.
    pub async fn get_or_try_insert_policy_version<F, E>(
        &self,
        chain_id: u64,
        policy_address: Address,
        init: F,
    ) -> Result<String, std::sync::Arc<E>>
    where
        F: std::future::Future<Output = Result<String, E>>,
        E: Send + Sync + 'static,
    {
        self.policy_version.try_get_with((chain_id, policy_address), init).await
    }

    // -- Invalidation --

    /// Remove a policy version entry (e.g., on proxy upgrade).
    pub async fn invalidate_policy_version(&self, chain_id: u64, policy_address: Address) {
        self.policy_version.invalidate(&(chain_id, policy_address)).await;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloy::primitives::Address;
    use std::time::Duration;

    fn test_config() -> PolicyContractCacheConfig {
        PolicyContractCacheConfig {
            version_ttl_secs: 1,
            version_max_capacity: 10,
        }
    }

    #[tokio::test]
    async fn test_version_cache_miss_then_hit() {
        let cache = PolicyContractCache::new(test_config());
        let chain_id = 1u64;
        let addr = Address::repeat_byte(0x01);

        assert!(cache.get_policy_version(chain_id, addr).await.is_none());

        cache.insert_policy_version(chain_id, addr, "0.3.0".to_string()).await;

        let cached = cache.get_policy_version(chain_id, addr).await.unwrap();
        assert_eq!(cached, "0.3.0");
    }

    #[tokio::test]
    async fn test_version_ttl_expiry() {
        let cache = PolicyContractCache::new(test_config());
        let chain_id = 1u64;
        let addr = Address::repeat_byte(0x01);

        cache.insert_policy_version(chain_id, addr, "0.3.0".to_string()).await;
        assert!(cache.get_policy_version(chain_id, addr).await.is_some());

        tokio::time::sleep(Duration::from_millis(1100)).await;

        assert!(cache.get_policy_version(chain_id, addr).await.is_none());
    }

    #[tokio::test]
    async fn test_default_config() {
        let config = PolicyContractCacheConfig::default();
        assert_eq!(config.version_ttl_secs, 600);
        assert_eq!(config.version_max_capacity, 512);
    }
}