Add support for missing RPC calls

avalanche-network-runner-sdk/rpcpb/rpc.proto

@@ -32,7 +32,10 @@ service ControlService {
   rpc AddPermissionlessValidator(AddPermissionlessValidatorRequest) returns (AddPermissionlessValidatorResponse) {
   }
 
-  rpc RemoveSubnetValidator(RemoveSubnetValidatorRequest) returns (RemoveSubnetValidatorResponse) {
+  rpc AddSubnetValidators(AddSubnetValidatorsRequest) returns (AddSubnetValidatorsResponse) {
+  }
+
+  rpc RemoveSubnetValidator(RemoveSubnetValidatorsRequest) returns (RemoveSubnetValidatorsResponse) {
   }
 
   rpc CreateSubnets(CreateSubnetsRequest) returns (CreateSubnetsResponse) {
@@ -59,6 +62,8 @@ service ControlService {
   rpc AddNode(AddNodeRequest) returns (AddNodeResponse) {
   }
 
+
+
   rpc RestartNode(RestartNodeRequest) returns (RestartNodeResponse) {
   }
 
@@ -283,6 +288,19 @@ message PermissionlessStakerSpec {
   uint64 stake_duration = 6;
 }
 
+message SubnetValidatorsSpec {
+  string subnet_id = 1;
+  repeated string node_names = 2;
+}
+
+message AddSubnetValidatorsRequest {
+  repeated SubnetValidatorsSpec validator_spec = 1;
+}
+
+message AddSubnetValidatorsResponse {
+  ClusterInfo cluster_info = 1;
+}
+
 message AddPermissionlessValidatorRequest {
   repeated PermissionlessStakerSpec validator_spec = 1;
 }
@@ -299,16 +317,16 @@ message AddPermissionlessDelegatorResponse {
   ClusterInfo cluster_info = 1;
 }
 
-message RemoveSubnetValidatorSpec {
+message RemoveSubnetValidatorsSpec {
   string subnet_id = 1;
   repeated string node_names = 2;
 }
 
-message RemoveSubnetValidatorRequest {
-  repeated RemoveSubnetValidatorSpec validator_spec = 1;
+message RemoveSubnetValidatorsRequest {
+  repeated RemoveSubnetValidatorsSpec validator_spec = 1;
 }
 
-message RemoveSubnetValidatorResponse {
+message RemoveSubnetValidatorsResponse {
   ClusterInfo cluster_info = 1;
 }
 

avalanche-network-runner-sdk/src/lib.rs

@@ -4,6 +4,11 @@ use std::{
 };
 
 use log::info;
+use rpcpb::{
+    AddPermissionlessValidatorRequest, AddPermissionlessValidatorResponse,
+    AddSubnetValidatorsRequest, AddSubnetValidatorsResponse, RemoveSubnetValidatorsRequest,
+    RemoveSubnetValidatorsResponse,
+};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 use tonic::transport::Channel;
@@ -13,8 +18,11 @@ pub mod rpcpb {
 }
 pub use rpcpb::{
     control_service_client::ControlServiceClient, ping_service_client::PingServiceClient,
-    BlockchainSpec, HealthRequest, HealthResponse, PingRequest, PingResponse, StartRequest,
-    StartResponse, StatusRequest, StatusResponse, StopRequest, StopResponse, UrIsRequest,
+    AddNodeRequest, AddNodeResponse, BlockchainSpec, HealthRequest, HealthResponse,
+    ListBlockchainsRequest, ListBlockchainsResponse, ListSubnetsRequest, ListSubnetsResponse,
+    PingRequest, PingResponse, RemoveNodeRequest, RemoveNodeResponse, StartRequest, StartResponse,
+    StatusRequest, StatusResponse, StopRequest, StopResponse, UrIsRequest, VmidRequest,
+    VmidResponse,
 };
 
 pub struct Client<T> {
@@ -132,6 +140,125 @@ impl Client<Channel> {
         let stop_resp = resp.into_inner();
         Ok(stop_resp)
     }
+
+    /// Add a node to the currently running cluster.
+    pub async fn add_node(&self, req: AddNodeRequest) -> io::Result<AddNodeResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .add_node(req)
+            .await
+            .map_err(|e| Error::new(ErrorKind::Other, format!("failed add_node '{}'", e)))?;
+
+        let add_node_resp = resp.into_inner();
+        Ok(add_node_resp)
+    }
+
+    /// Remove a node from the currently running cluster.
+    pub async fn remove_node(&self, req: RemoveNodeRequest) -> io::Result<RemoveNodeResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .remove_node(req)
+            .await
+            .map_err(|e| Error::new(ErrorKind::Other, format!("failed remove_node '{}'", e)))?;
+
+        let remove_node_resp = resp.into_inner();
+        Ok(remove_node_resp)
+    }
+
+    /// Adds a new permissionless validator to the network.
+    pub async fn add_permissionless_validator(
+        &self,
+        req: AddPermissionlessValidatorRequest,
+    ) -> io::Result<AddPermissionlessValidatorResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .add_permissionless_validator(req)
+            .await
+            .map_err(|e| {
+                Error::new(
+                    ErrorKind::Other,
+                    format!("failed add_permissionless_validator '{}'", e),
+                )
+            })?;
+        let resp = resp.into_inner();
+        Ok(resp)
+    }
+
+    /// Adds a new permissionless validator to the network.
+    pub async fn add_validator(
+        &self,
+        req: AddSubnetValidatorsRequest,
+    ) -> io::Result<AddSubnetValidatorsResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .add_subnet_validators(req)
+            .await
+            .map_err(|e| Error::new(ErrorKind::Other, format!("failed add_validators '{}'", e)))?;
+        let resp = resp.into_inner();
+        Ok(resp)
+    }
+
+    /// Removes a validator from the network.
+    pub async fn remove_validator(
+        &self,
+        req: RemoveSubnetValidatorsRequest,
+    ) -> io::Result<RemoveSubnetValidatorsResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .remove_subnet_validator(req)
+            .await
+            .map_err(|e| {
+                Error::new(
+                    ErrorKind::Other,
+                    format!("failed remove_validators '{}'", e),
+                )
+            })?;
+        let resp = resp.into_inner();
+        Ok(resp)
+    }
+
+    /// Fetches the VM ID for the current cluster.
+    pub async fn vm_id(&self, req: VmidRequest) -> io::Result<VmidResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .vmid(req)
+            .await
+            .map_err(|e| Error::new(ErrorKind::Other, format!("failed vm_id '{}'", e)))?;
+        let resp = resp.into_inner();
+        Ok(resp)
+    }
+
+    /// Fetches the list of blockchains for the current cluster.
+    pub async fn list_blockchains(
+        &self,
+        req: ListBlockchainsRequest,
+    ) -> io::Result<ListBlockchainsResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client.list_blockchains(req).await.map_err(|e| {
+            Error::new(ErrorKind::Other, format!("failed list_blockchains '{}'", e))
+        })?;
+        let resp = resp.into_inner();
+        Ok(resp)
+    }
+
+    /// Fetches the list of subnets for the current cluster.
+    pub async fn list_subnets(&self, req: ListSubnetsRequest) -> io::Result<ListSubnetsResponse> {
+        let mut control_client = self.grpc_client.control_client.lock().await;
+        let req = tonic::Request::new(req);
+        let resp = control_client
+            .list_subnets(req)
+            .await
+            .map_err(|e| Error::new(ErrorKind::Other, format!("failed list_subnets '{}'", e)))?;
+        let resp = resp.into_inner();
+        Ok(resp)
+    }
 }
 
 #[test]