feat(sui): add gRPC migration level 6 for service info methods

Author: wbbradley

crates/walrus-sui/src/client/dual_client.rs

@@ -18,9 +18,12 @@ use sui_rpc::{
         BatchGetObjectsResponse,
         Bcs,
         DynamicField,
+        Epoch as GrpcEpoch,
         ExecutedTransaction,
         GetBalanceRequest,
+        GetEpochRequest,
         GetObjectRequest,
+        GetServiceInfoRequest,
         GetTransactionRequest,
         ListDynamicFieldsRequest,
         ListOwnedObjectsRequest,
@@ -30,11 +33,11 @@ use sui_rpc::{
         state_service_client::StateServiceClient,
     },
 };
-use sui_sdk::{SuiClient, SuiClientBuilder};
+use sui_sdk::{SuiClient, SuiClientBuilder, rpc_types::SuiCommittee};
 use sui_types::{
     TypeTag,
     base_types::{ObjectID, ObjectRef, SuiAddress},
-    crypto::ToFromBytes,
+    crypto::{AuthorityPublicKeyBytes, ToFromBytes},
     digests::TransactionDigest,
     event::EventID,
     signature::GenericSignature,
@@ -594,6 +597,74 @@ impl DualClient {
             next_cursor: response.next_page_token,
         })
     }
+
+    /// Get the chain identifier via gRPC.
+    pub async fn get_chain_identifier_grpc(&self) -> Result<String, SuiClientError> {
+        let mut grpc_client = self.grpc_client.clone();
+        let response = grpc_client
+            .ledger_client()
+            .get_service_info(GetServiceInfoRequest::default())
+            .await?;
+        Ok(response
+            .into_inner()
+            .chain_id
+            .context("no chain_id in get_service_info response")?)
+    }
+
+    /// Get the reference gas price for the current epoch via gRPC.
+    pub async fn get_reference_gas_price_grpc(&self) -> Result<u64, SuiClientError> {
+        let request = GetEpochRequest::default().with_read_mask(FieldMask::from_paths([
+            GrpcEpoch::path_builder().reference_gas_price(),
+        ]));
+        let mut grpc_client = self.grpc_client.clone();
+        let response = grpc_client.ledger_client().get_epoch(request).await?;
+        Ok(response
+            .into_inner()
+            .epoch
+            .context("no epoch in get_epoch response")?
+            .reference_gas_price
+            .context("no reference_gas_price in epoch")?)
+    }
+
+    /// Get the committee info for the given epoch via gRPC.
+    pub async fn get_committee_info_grpc(
+        &self,
+        epoch: Option<u64>,
+    ) -> Result<SuiCommittee, SuiClientError> {
+        let mut request = GetEpochRequest::default().with_read_mask(FieldMask::from_paths([
+            GrpcEpoch::path_builder().epoch(),
+            GrpcEpoch::path_builder().committee().finish(),
+        ]));
+        if let Some(e) = epoch {
+            request = request.with_epoch(e);
+        }
+
+        let mut grpc_client = self.grpc_client.clone();
+        let response = grpc_client.ledger_client().get_epoch(request).await?;
+        let epoch_data = response
+            .into_inner()
+            .epoch
+            .context("no epoch in get_epoch response")?;
+        let committee = epoch_data.committee.context("no committee in epoch")?;
+        let validators = committee
+            .members
+            .iter()
+            .map(|member| {
+                let pk_bytes = member
+                    .public_key
+                    .as_ref()
+                    .context("no public_key in committee member")?;
+                let pk = AuthorityPublicKeyBytes::from_bytes(pk_bytes)
+                    .map_err(|e| anyhow::anyhow!("invalid authority public key: {e}"))?;
+                let weight = member.weight.context("no weight in committee member")?;
+                Ok((pk, weight))
+            })
+            .collect::<Result<Vec<_>, anyhow::Error>>()?;
+        Ok(SuiCommittee {
+            epoch: epoch_data.epoch.context("no epoch number")?,
+            validators,
+        })
+    }
 }
 
 async fn list_owned_objects(

crates/walrus-sui/src/client/retry_client/retriable_sui_client.rs

@@ -214,6 +214,7 @@ const GRPC_MIGRATION_LEVEL_BATCH_OBJECTS: GrpcMigrationLevel = GrpcMigrationLeve
 const GRPC_MIGRATION_LEVEL_SELECT_COINS: GrpcMigrationLevel = GrpcMigrationLevel(3);
 const GRPC_MIGRATION_LEVEL_GET_BALANCE: GrpcMigrationLevel = GrpcMigrationLevel(4);
 const GRPC_MIGRATION_LEVEL_TRANSACTION_READS: GrpcMigrationLevel = GrpcMigrationLevel(5);
+const GRPC_MIGRATION_LEVEL_SERVICE_INFO: GrpcMigrationLevel = GrpcMigrationLevel(6);
 
 impl Default for GrpcMigrationLevel {
     fn default() -> Self {
@@ -1245,54 +1246,105 @@ impl RetriableSuiClient {
     }
 
     /// Returns the committee information for the given epoch.
-    ///
-    /// Calls [`sui_sdk::apis::GovernanceApi::get_committee_info`] internally.
     pub async fn get_committee_info(
         &self,
         epoch: Option<BigInt<u64>>,
     ) -> SuiClientResult<SuiCommittee> {
-        async fn make_request(
-            client: Arc<DualClient>,
-            epoch: Option<BigInt<u64>>,
-        ) -> SuiClientResult<SuiCommittee> {
-            Ok(client
-                .sui_client()
-                .governance_api()
-                .get_committee_info(epoch)
-                .await?)
+        if self.grpc_migration_level >= GRPC_MIGRATION_LEVEL_SERVICE_INFO {
+            self.get_committee_info_grpc(epoch.map(|b| *b)).await
+        } else {
+            self.get_committee_info_json_rpc(epoch).await
         }
+    }
 
+    /// JSON-RPC implementation of `get_committee_info`.
+    async fn get_committee_info_json_rpc(
+        &self,
+        epoch: Option<BigInt<u64>>,
+    ) -> SuiClientResult<SuiCommittee> {
         let request = move |client: Arc<DualClient>, method| {
             retry_rpc_errors(
                 self.get_strategy(),
-                move || make_request(client.clone(), epoch),
+                move || {
+                    let client = client.clone();
+                    async move {
+                        Ok(client
+                            .sui_client()
+                            .governance_api()
+                            .get_committee_info(epoch)
+                            .await?)
+                    }
+                },
                 self.metrics.clone(),
                 method,
             )
         };
+        self.failover_sui_client
+            .with_failover(request, None, "get_committee_info")
+            .await
+    }
 
+    /// gRPC implementation of `get_committee_info`.
+    async fn get_committee_info_grpc(&self, epoch: Option<u64>) -> SuiClientResult<SuiCommittee> {
+        let request = move |client: Arc<DualClient>, method| {
+            retry_rpc_errors(
+                self.get_strategy(),
+                move || {
+                    let client = client.clone();
+                    async move { client.get_committee_info_grpc(epoch).await }
+                },
+                self.metrics.clone(),
+                method,
+            )
+        };
         self.failover_sui_client
             .with_failover(request, None, "get_committee_info")
             .await
     }
 
     /// Returns the reference gas price.
-    ///
-    /// Calls [`sui_sdk::apis::ReadApi::get_reference_gas_price`] internally.
     #[tracing::instrument(level = Level::DEBUG, skip_all)]
     pub async fn get_reference_gas_price(&self) -> SuiClientResult<u64> {
-        async fn make_request(client: Arc<DualClient>) -> SuiClientResult<u64> {
-            Ok(client
-                .sui_client()
-                .read_api()
-                .get_reference_gas_price()
-                .await?)
+        if self.grpc_migration_level >= GRPC_MIGRATION_LEVEL_SERVICE_INFO {
+            self.get_reference_gas_price_grpc().await
+        } else {
+            self.get_reference_gas_price_json_rpc().await
         }
+    }
+
+    /// JSON-RPC implementation of `get_reference_gas_price`.
+    async fn get_reference_gas_price_json_rpc(&self) -> SuiClientResult<u64> {
+        let request = move |client: Arc<DualClient>, method| {
+            retry_rpc_errors(
+                self.get_strategy(),
+                move || {
+                    let client = client.clone();
+                    async move {
+                        Ok(client
+                            .sui_client()
+                            .read_api()
+                            .get_reference_gas_price()
+                            .await?)
+                    }
+                },
+                self.metrics.clone(),
+                method,
+            )
+        };
+        self.failover_sui_client
+            .with_failover(request, None, "get_reference_gas_price")
+            .await
+    }
 
+    /// gRPC implementation of `get_reference_gas_price`.
+    async fn get_reference_gas_price_grpc(&self) -> SuiClientResult<u64> {
         let request = move |client: Arc<DualClient>, method| {
             retry_rpc_errors(
                 self.get_strategy(),
-                move || make_request(client.clone()),
+                move || {
+                    let client = client.clone();
+                    async move { client.get_reference_gas_price_grpc().await }
+                },
                 self.metrics.clone(),
                 method,
             )
@@ -1466,20 +1518,47 @@ impl RetriableSuiClient {
     }
 
     /// Returns the chain identifier.
-    ///
-    /// Calls [`sui_sdk::apis::ReadApi::get_chain_identifier`] internally.
     pub async fn get_chain_identifier(&self) -> SuiClientResult<String> {
-        async fn make_request(client: Arc<DualClient>) -> SuiClientResult<String> {
-            Ok(client
-                .sui_client()
-                .read_api()
-                .get_chain_identifier()
-                .await?)
+        if self.grpc_migration_level >= GRPC_MIGRATION_LEVEL_SERVICE_INFO {
+            self.get_chain_identifier_grpc().await
+        } else {
+            self.get_chain_identifier_json_rpc().await
         }
+    }
+
+    /// JSON-RPC implementation of `get_chain_identifier`.
+    async fn get_chain_identifier_json_rpc(&self) -> SuiClientResult<String> {
+        let request = move |client: Arc<DualClient>, method| {
+            retry_rpc_errors(
+                self.get_strategy(),
+                move || {
+                    let client = client.clone();
+                    async move {
+                        Ok(client
+                            .sui_client()
+                            .read_api()
+                            .get_chain_identifier()
+                            .await?)
+                    }
+                },
+                self.metrics.clone(),
+                method,
+            )
+        };
+        self.failover_sui_client
+            .with_failover(request, None, "get_chain_identifier")
+            .await
+    }
+
+    /// gRPC implementation of `get_chain_identifier`.
+    async fn get_chain_identifier_grpc(&self) -> SuiClientResult<String> {
         let request = move |client: Arc<DualClient>, method| {
             retry_rpc_errors(
                 self.get_strategy(),
-                move || make_request(client.clone()),
+                move || {
+                    let client = client.clone();
+                    async move { client.get_chain_identifier_grpc().await }
+                },
                 self.metrics.clone(),
                 method,
             )