feat(gRPC): gRPC proto files for internal usage (#9044)

# Description of change

- Initialize the gRPC proto files, which addressed APIs documented in
#8688.
- Note that the design of gRPC request/response in is that we focus on
returning low-level BCS iota-type data, instead of extracting fields
from the iota-type data and put them in response in most cases (to
discuss).

## Links to any relevant issues

Part of #8688

## How the change has been tested

- [x] Basic tests (linting, compilation, formatting, unit/integration
tests)
- [ ] Patch-specific tests (correctness, functionality coverage)
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [ ] I have checked that new and existing unit tests pass locally with
my changes

---------

Co-authored-by: muXxer <git@muxxer.de>

Author: bingyanglin

.cargo/config.toml

@@ -1,7 +1,7 @@
 [alias]
 ci-fmt = "fmt --check"
 ci-clippy = "clippy --all-targets --all-features -- -D warnings"
-ci-license = "license-template --template .license_template"
+ci-license = "license-template --template .license_template --ignore .licenseignore"
 ci-udeps = "udeps --all-targets --backend=depinfo"
 ci-udeps-external = "udeps --all-targets --manifest-path external-crates/move/Cargo.toml --backend=depinfo"
 

.licenseignore

@@ -0,0 +1,2 @@
+# Generated protobuf files from Google
+crates/iota-grpc-types/src/proto_generated/google.*

crates/iota-grpc-client/src/checkpoint.rs

@@ -0,0 +1,23 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use iota_grpc_types::v0::ledger_service as grpc_ledger_service;
+use tonic::transport::Channel;
+
+/// Dedicated client for ledger-related gRPC operations.
+///
+/// This client handles all ledger service interactions like getting objects,
+/// transactions, checkpoints, epochs and a service info.
+#[derive(Clone)]
+pub struct LedgerClient {
+    _client: grpc_ledger_service::ledger_service_client::LedgerServiceClient<Channel>,
+}
+
+impl LedgerClient {
+    /// Create a new LedgerClient from a shared gRPC channel.
+    pub(super) fn new(channel: Channel) -> Self {
+        Self {
+            _client: grpc_ledger_service::ledger_service_client::LedgerServiceClient::new(channel),
+        }
+    }
+}

crates/iota-grpc-client/src/event.rs

@@ -3,10 +3,8 @@
 
 //! gRPC client for IOTA node operations.
 
-mod checkpoint;
-mod event;
+mod ledger;
 mod node_client;
 
-pub use checkpoint::{CheckpointClient, CheckpointContent};
-pub use event::EventClient;
+pub use ledger::LedgerClient;
 pub use node_client::NodeClient;

crates/iota-grpc-client/src/ledger.rs

@@ -5,16 +5,14 @@ use std::sync::OnceLock;
 
 use tonic::transport::Channel;
 
-use super::{checkpoint::CheckpointClient, event::EventClient};
+use crate::LedgerClient;
 
 /// gRPC client factory for IOTA node operations.
 pub struct NodeClient {
     /// Shared gRPC channel for all service clients
     channel: Channel,
-    /// Cached checkpoint client (singleton)
-    checkpoint_client: OnceLock<CheckpointClient>,
-    /// Cached event client (singleton)
-    event_client: OnceLock<EventClient>,
+    /// Cached ledger client (singleton)
+    ledger_client: OnceLock<LedgerClient>,
 }
 
 impl NodeClient {
@@ -24,8 +22,7 @@ impl NodeClient {
 
         Ok(Self {
             channel,
-            checkpoint_client: OnceLock::new(),
-            event_client: OnceLock::new(),
+            ledger_client: OnceLock::new(),
         })
     }
 
@@ -41,32 +38,17 @@ impl NodeClient {
     // Service Client Factories
     // ========================================
 
-    /// Get a checkpoint service client.
+    /// Get a ledger service client.
     ///
-    /// Returns `Some(CheckpointClient)` if the node supports checkpoint
+    /// Returns `Some(LedgerClient)` if the node supports ledger-related
     /// operations, `None` otherwise. The client is created only once and
     /// cached for subsequent calls.
-    pub fn checkpoint_client(&self) -> Option<CheckpointClient> {
-        // For now, always return Some since checkpoint service is always available
+    pub fn ledger_service_client(&self) -> Option<super::ledger::LedgerClient> {
+        // For now, always return Some since ledger service is always available
         // In the future, this could check node capabilities first
         Some(
-            self.checkpoint_client
-                .get_or_init(|| CheckpointClient::new(self.channel.clone()))
-                .clone(),
-        )
-    }
-
-    /// Get an event service client.
-    ///
-    /// Returns `Some(EventClient)` if the node supports event streaming
-    /// operations, `None` otherwise. The client is created only once and
-    /// cached for subsequent calls.
-    pub fn event_client(&self) -> Option<EventClient> {
-        // For now, always return Some since event service is always available
-        // In the future, this could check node capabilities first
-        Some(
-            self.event_client
-                .get_or_init(|| EventClient::new(self.channel.clone()))
+            self.ledger_client
+                .get_or_init(|| LedgerClient::new(self.channel.clone()))
                 .clone(),
         )
     }