add toek nbalances api to client

crates/torii/client/src/client/mod.rs

@@ -11,9 +11,12 @@ use starknet::providers::jsonrpc::HttpTransport;
 use starknet::providers::JsonRpcClient;
 use tokio::sync::RwLock as AsyncRwLock;
 use torii_grpc::client::{EntityUpdateStreaming, EventUpdateStreaming, IndexerUpdateStreaming};
-use torii_grpc::proto::world::{RetrieveEntitiesResponse, RetrieveEventsResponse};
+use torii_grpc::proto::world::{
+    RetrieveEntitiesResponse, RetrieveEventsResponse, RetrieveTokenBalancesResponse,
+    RetrieveTokensResponse,
+};
 use torii_grpc::types::schema::Entity;
-use torii_grpc::types::{EntityKeysClause, Event, EventQuery, Query};
+use torii_grpc::types::{EntityKeysClause, Event, EventQuery, Query, Token, TokenBalance};
 use torii_relay::client::EventLoop;
 use torii_relay::types::Message;
 
@@ -85,6 +88,26 @@ impl Client {
         self.metadata.read()
     }
 
+    /// Retrieves tokens matching contract addresses.
+    pub async fn tokens(&self, contract_addresses: Vec<Felt>) -> Result<Vec<Token>, Error> {
+        let mut grpc_client = self.inner.write().await;
+        let RetrieveTokensResponse { tokens } =
+            grpc_client.retrieve_tokens(contract_addresses).await?;
+        Ok(tokens.into_iter().map(TryInto::try_into).collect::<Result<Vec<Token>, _>>()?)
+    }
+
+    /// Retrieves token balances for account addresses and contract addresses.
+    pub async fn token_balances(
+        &self,
+        account_addresses: Vec<Felt>,
+        contract_addresses: Vec<Felt>,
+    ) -> Result<Vec<TokenBalance>, Error> {
+        let mut grpc_client = self.inner.write().await;
+        let RetrieveTokenBalancesResponse { balances } =
+            grpc_client.retrieve_token_balances(account_addresses, contract_addresses).await?;
+        Ok(balances.into_iter().map(TryInto::try_into).collect::<Result<Vec<TokenBalance>, _>>()?)
+    }
+
     /// Retrieves entities matching query parameter.
     ///
     /// The query param includes an optional clause for filtering. Without clause, it fetches ALL

crates/torii/grpc/src/client.rs

@@ -11,11 +11,13 @@ use tonic::transport::Endpoint;
 
 use crate::proto::world::{
     world_client, RetrieveEntitiesRequest, RetrieveEntitiesResponse, RetrieveEventMessagesRequest,
-    RetrieveEventsRequest, RetrieveEventsResponse, SubscribeEntitiesRequest,
-    SubscribeEntityResponse, SubscribeEventMessagesRequest, SubscribeEventsRequest,
-    SubscribeEventsResponse, SubscribeIndexerRequest, SubscribeIndexerResponse,
-    SubscribeModelsRequest, SubscribeModelsResponse, UpdateEntitiesSubscriptionRequest,
-    UpdateEventMessagesSubscriptionRequest, WorldMetadataRequest,
+    RetrieveEventsRequest, RetrieveEventsResponse, RetrieveTokenBalancesRequest,
+    RetrieveTokenBalancesResponse, RetrieveTokensRequest, RetrieveTokensResponse,
+    SubscribeEntitiesRequest, SubscribeEntityResponse, SubscribeEventMessagesRequest,
+    SubscribeEventsRequest, SubscribeEventsResponse, SubscribeIndexerRequest,
+    SubscribeIndexerResponse, SubscribeModelsRequest, SubscribeModelsResponse,
+    UpdateEntitiesSubscriptionRequest, UpdateEventMessagesSubscriptionRequest,
+    WorldMetadataRequest,
 };
 use crate::types::schema::{Entity, SchemaError};
 use crate::types::{EntityKeysClause, Event, EventQuery, IndexerUpdate, ModelKeysClause, Query};
@@ -90,6 +92,43 @@ impl WorldClient {
             .and_then(|metadata| metadata.try_into().map_err(Error::ParseStr))
     }
 
+    pub async fn retrieve_tokens(
+        &mut self,
+        contract_addresses: Vec<Felt>,
+    ) -> Result<RetrieveTokensResponse, Error> {
+        self.inner
+            .retrieve_tokens(RetrieveTokensRequest {
+                contract_addresses: contract_addresses
+                    .into_iter()
+                    .map(|c| c.to_bytes_be().to_vec())
+                    .collect(),
+            })
+            .await
+            .map_err(Error::Grpc)
+            .map(|res| res.into_inner())
+    }
+
+    pub async fn retrieve_token_balances(
+        &mut self,
+        account_addresses: Vec<Felt>,
+        contract_addresses: Vec<Felt>,
+    ) -> Result<RetrieveTokenBalancesResponse, Error> {
+        self.inner
+            .retrieve_token_balances(RetrieveTokenBalancesRequest {
+                account_addresses: account_addresses
+                    .into_iter()
+                    .map(|a| a.to_bytes_be().to_vec())
+                    .collect(),
+                contract_addresses: contract_addresses
+                    .into_iter()
+                    .map(|c| c.to_bytes_be().to_vec())
+                    .collect(),
+            })
+            .await
+            .map_err(Error::Grpc)
+            .map(|res| res.into_inner())
+    }
+
     pub async fn retrieve_entities(
         &mut self,
         query: Query,

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

@@ -2,9 +2,11 @@ use core::fmt;
 use std::collections::HashMap;
 use std::str::FromStr;
 
+use crypto_bigint::U256;
 use dojo_types::primitive::Primitive;
 use dojo_types::schema::Ty;
 use dojo_world::contracts::naming;
+use schema::SchemaError;
 use serde::{Deserialize, Serialize};
 use starknet::core::types::{
     ContractStorageDiffItem, Felt, FromStrError, StateDiff, StateUpdate, StorageEntry,
@@ -16,6 +18,48 @@ use crate::proto::{self};
 
 pub mod schema;
 
+#[derive(Debug, Serialize, Deserialize, PartialEq, Hash, Eq, Clone)]
+pub struct Token {
+    pub contract_address: Felt,
+    pub name: String,
+    pub symbol: String,
+    pub decimals: u8,
+    pub metadata: String,
+}
+
+impl TryFrom<proto::types::Token> for Token {
+    type Error = SchemaError;
+    fn try_from(value: proto::types::Token) -> Result<Self, Self::Error> {
+        Ok(Self {
+            contract_address: Felt::from_str(&value.contract_address)?,
+            name: value.name,
+            symbol: value.symbol,
+            decimals: value.decimals as u8,
+            metadata: value.metadata,
+        })
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Hash, Eq, Clone)]
+pub struct TokenBalance {
+    pub balance: U256,
+    pub account_address: Felt,
+    pub contract_address: Felt,
+    pub token_id: String,
+}
+
+impl TryFrom<proto::types::TokenBalance> for TokenBalance {
+    type Error = SchemaError;
+    fn try_from(value: proto::types::TokenBalance) -> Result<Self, Self::Error> {
+        Ok(Self {
+            balance: U256::from_be_hex(&value.balance),
+            account_address: Felt::from_str(&value.account_address)?,
+            contract_address: Felt::from_str(&value.contract_address)?,
+            token_id: value.token_id,
+        })
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, PartialEq, Hash, Eq, Clone)]
 pub struct IndexerUpdate {
     pub head: i64,