apollo_l1_gas_price_types,apollo_l1_gas_price: rename trait method eth_to_fri_rate to fetch_rate

Author: sirandreww-starkware

crates/apollo_l1_gas_price/src/exchange_rate_oracle.rs

@@ -204,7 +204,7 @@ impl ExchangeRateOracleClientTrait for ExchangeRateOracleClient {
     /// - `price`: a hexadecimal string representing the price.
     /// - `decimals`: a `u64` value, must be equal to `EXCHANGE_RATE_DECIMALS`.
     #[instrument(skip(self))]
-    async fn eth_to_fri_rate(&self, timestamp: u64) -> Result<u128, ExchangeRateOracleClientError> {
+    async fn fetch_rate(&self, timestamp: u64) -> Result<u128, ExchangeRateOracleClientError> {
         const NUMBER_OF_TIMESTAMPS_BACK: u64 = 1;
         let quantized_timestamp = (timestamp - self.config.lag_interval_seconds)
             .checked_div(self.config.lag_interval_seconds)

crates/apollo_l1_gas_price/src/exchange_rate_oracle_test.rs

@@ -60,16 +60,14 @@ async fn eth_to_fri_rate_uses_cache_on_quantized_hit() {
     let client = ExchangeRateOracleClient::new(config.clone());
 
     // First request should fail because the cache is empty.
-    assert!(client.eth_to_fri_rate(TIMESTAMP1).await.is_err());
+    assert!(client.fetch_rate(TIMESTAMP1).await.is_err());
     // Wait for the query to resolve.
-    while client.eth_to_fri_rate(TIMESTAMP1).await.is_err() {
+    while client.fetch_rate(TIMESTAMP1).await.is_err() {
         tokio::task::yield_now().await; // Don't block the executor.
     }
-    let rate1 = client.eth_to_fri_rate(TIMESTAMP1).await.unwrap();
-    let rate2 = client
-        .eth_to_fri_rate(TIMESTAMP2)
-        .await
-        .expect("Should resolve immediately due to the cache");
+    let rate1 = client.fetch_rate(TIMESTAMP1).await.unwrap();
+    let rate2 =
+        client.fetch_rate(TIMESTAMP2).await.expect("Should resolve immediately due to the cache");
     assert_eq!(rate1, rate2);
 }
 
@@ -134,28 +132,28 @@ async fn eth_to_fri_rate_uses_prev_cache_when_query_not_ready() {
     let client = ExchangeRateOracleClient::new(config.clone());
 
     // First request should fail because the cache is empty.
-    assert!(client.eth_to_fri_rate(TIMESTAMP1).await.is_err());
+    assert!(client.fetch_rate(TIMESTAMP1).await.is_err());
     // Wait for the query to resolve.
-    while client.eth_to_fri_rate(TIMESTAMP1).await.is_err() {
+    while client.fetch_rate(TIMESTAMP1).await.is_err() {
         tokio::task::yield_now().await; // Don't block the executor.
     }
-    let rate1 = client.eth_to_fri_rate(TIMESTAMP1).await.unwrap();
+    let rate1 = client.fetch_rate(TIMESTAMP1).await.unwrap();
     assert_eq!(rate1, EXPECTED_RATE);
     // Second request should resolve immediately due to the cache.
-    let rate2 = client.eth_to_fri_rate(TIMESTAMP2).await.unwrap();
+    let rate2 = client.fetch_rate(TIMESTAMP2).await.unwrap();
     assert_eq!(rate2, EXPECTED_RATE);
 
     // Wait for the query to resolve, and the price to be updated.
     for _ in 0..100 {
-        let current_rate = client.eth_to_fri_rate(TIMESTAMP2).await.unwrap();
+        let current_rate = client.fetch_rate(TIMESTAMP2).await.unwrap();
         if current_rate > EXPECTED_RATE {
             break;
         }
         tokio::time::sleep(Duration::from_millis(1)).await;
     }
 
     // Third request should already successfully get the query from the server.
-    let rate3 = client.eth_to_fri_rate(TIMESTAMP2).await.unwrap();
+    let rate3 = client.fetch_rate(TIMESTAMP2).await.unwrap();
     assert_eq!(rate3, different_rate);
 }
 
@@ -194,22 +192,22 @@ async fn eth_to_fri_rate_two_urls() {
     };
     let client = ExchangeRateOracleClient::new(config.clone());
     // First request should fail because the cache is empty.
-    assert!(client.eth_to_fri_rate(TIMESTAMP1).await.is_err());
+    assert!(client.fetch_rate(TIMESTAMP1).await.is_err());
     // Wait for the query to resolve.
-    while client.eth_to_fri_rate(TIMESTAMP1).await.is_err() {
+    while client.fetch_rate(TIMESTAMP1).await.is_err() {
         tokio::task::yield_now().await; // Don't block the executor.
     }
-    let rate1 = client.eth_to_fri_rate(TIMESTAMP1).await.unwrap();
+    let rate1 = client.fetch_rate(TIMESTAMP1).await.unwrap();
     assert_eq!(rate1, EXPECTED_RATE);
 
     // Note this server fails on missing "decimals", not "price".
     let _mock_response3 =
         make_server(&mut server2, json!({"price": &expected_rate_hex, "bar": 18})).await;
     // First request should fail because the cache is empty.
-    assert!(client.eth_to_fri_rate(TIMESTAMP2).await.is_err());
+    assert!(client.fetch_rate(TIMESTAMP2).await.is_err());
     // Wait for the query to resolve.
     loop {
-        match client.eth_to_fri_rate(TIMESTAMP2).await {
+        match client.fetch_rate(TIMESTAMP2).await {
             Ok(_) => panic!("Both servers should be returning bad JSON!"),
             Err(ExchangeRateOracleClientError::QueryNotReadyError(_)) => {}
             Err(ExchangeRateOracleClientError::AllUrlsFailedError(_, index)) => {

crates/apollo_l1_gas_price/src/l1_gas_price_provider.rs

@@ -186,7 +186,7 @@ impl L1GasPriceProvider {
 
     pub async fn eth_to_fri_rate(&self, timestamp: u64) -> L1GasPriceProviderResult<u128> {
         self.eth_to_strk_oracle_client
-            .eth_to_fri_rate(timestamp)
+            .fetch_rate(timestamp)
             .await
             .map_err(L1GasPriceProviderError::ExchangeRateOracleClientError)
     }

crates/apollo_l1_gas_price_types/src/lib.rs

@@ -105,8 +105,10 @@ pub trait L1GasPriceProviderClient: Send + Sync {
 #[cfg_attr(any(feature = "testing", test), automock)]
 #[async_trait]
 pub trait ExchangeRateOracleClientTrait: Send + Sync + Debug {
-    /// Fetches the eth to fri rate for a given timestamp.
-    async fn eth_to_fri_rate(&self, timestamp: u64) -> Result<u128, ExchangeRateOracleClientError>;
+    /// Fetches a rate as a u128 for the given timestamp. The semantics of the rate (e.g.
+    /// ETH/FRI, STRK/USD) are determined by the URLs the implementation is configured with;
+    /// callers label the per-instance meaning at the field that holds the trait object.
+    async fn fetch_rate(&self, timestamp: u64) -> Result<u128, ExchangeRateOracleClientError>;
 }
 
 #[async_trait]