feat(torii): retrieve controllers & usernames graphql and grpc

crates/torii/grpc/proto/types.proto

@@ -185,4 +185,10 @@ message OrderBy {
 enum OrderDirection {
     ASC = 0;
     DESC = 1;
+}
+
+message Controller {
+    bytes address = 1;
+    string username = 2;
+    uint64 deployed_at_timestamp = 3;
 }

crates/torii/grpc/proto/world.proto

@@ -54,6 +54,17 @@ service World {
 
     // Retrieve token balances
     rpc RetrieveTokenBalances (RetrieveTokenBalancesRequest) returns (RetrieveTokenBalancesResponse);
+
+    // Retrieve controllers
+    rpc RetrieveControllers (RetrieveControllersRequest) returns (RetrieveControllersResponse);
+}
+
+message RetrieveControllersRequest {
+    repeated bytes contract_addresses = 1;
+}
+
+message RetrieveControllersResponse {
+    repeated types.Controller controllers = 1;
 }
 
 // A request to update a token balance subscription

crates/torii/grpc/src/server/mod.rs

@@ -56,12 +56,13 @@
 use crate::proto::types::LogicalOperator;
 use crate::proto::world::world_server::WorldServer;
 use crate::proto::world::{
-    RetrieveEntitiesStreamingResponse, RetrieveEventMessagesRequest, RetrieveTokenBalancesRequest,
-    RetrieveTokenBalancesResponse, RetrieveTokensRequest, RetrieveTokensResponse,
-    SubscribeEntitiesRequest, SubscribeEntityResponse, SubscribeEventMessagesRequest,
-    SubscribeEventsResponse, SubscribeIndexerRequest, SubscribeIndexerResponse,
-    SubscribeTokenBalancesResponse, UpdateEventMessagesSubscriptionRequest,
-    UpdateTokenBalancesSubscriptionRequest, WorldMetadataRequest, WorldMetadataResponse,
+    RetrieveControllersRequest, RetrieveControllersResponse, RetrieveEntitiesStreamingResponse,
+    RetrieveEventMessagesRequest, RetrieveTokenBalancesRequest, RetrieveTokenBalancesResponse,
+    RetrieveTokensRequest, RetrieveTokensResponse, SubscribeEntitiesRequest,
+    SubscribeEntityResponse, SubscribeEventMessagesRequest, SubscribeEventsResponse,
+    SubscribeIndexerRequest, SubscribeIndexerResponse, SubscribeTokenBalancesResponse,
+    UpdateEventMessagesSubscriptionRequest, UpdateTokenBalancesSubscriptionRequest,
+    WorldMetadataRequest, WorldMetadataResponse,
 };
 use crate::proto::{self};
 use crate::types::schema::SchemaError;
@@ -1042,6 +1043,38 @@
             .add_subscriber(clause.into_iter().map(|keys| keys.into()).collect())
             .await
     }
+
+    async fn retrieve_controllers(
+        &self,
+        contract_addresses: Vec<Felt>,
+    ) -> Result<proto::world::RetrieveControllersResponse, Error> {
+        let query = if contract_addresses.is_empty() {
+            "SELECT address, username, deployed_at FROM controllers".to_string()
+        } else {
+            format!(
+                "SELECT address, username, deployed_at FROM controllers WHERE address IN ({})",
+                contract_addresses.iter().map(|_| "?".to_string()).collect::<Vec<_>>().join(", ")
+            )
+        };
+
+        let mut db_query = sqlx::query_as::<_, (String, String, u64)>(&query);
+        for address in &contract_addresses {
+            db_query = db_query.bind(format!("{:#x}", address));
+        }
+
+        let rows = db_query.fetch_all(&self.pool).await?;
+
+        let controllers = rows
+            .into_iter()
+            .map(|(address, username, deployed_at)| proto::types::Controller {
+                address: address.parse::<Felt>().unwrap().to_bytes_be().to_vec(),
+                username,
+                deployed_at_timestamp: deployed_at,
+            })
+            .collect();
+
+        Ok(RetrieveControllersResponse { controllers })
+    }
 }
 
 fn process_event_field(data: &str) -> Result<Vec<Vec<u8>>, Error> {
@@ -1271,6 +1304,23 @@
         Ok(Response::new(WorldMetadataResponse { metadata }))
     }
 
+    async fn retrieve_controllers(
+        &self,
+        request: Request<RetrieveControllersRequest>,
+    ) -> Result<Response<RetrieveControllersResponse>, Status> {
+        let RetrieveControllersRequest { contract_addresses } = request.into_inner();
+        let contract_addresses = contract_addresses
+            .iter()
+            .map(|address| Felt::from_bytes_be_slice(address))
+            .collect::<Vec<_>>();
+
+        let controllers = self
+            .retrieve_controllers(contract_addresses)
+            .await
+            .map_err(|e| Status::internal(e.to_string()))?;
+        Ok(Response::new(controllers))
+    }
+
     async fn retrieve_tokens(
         &self,
         request: Request<RetrieveTokensRequest>,