Merge pull request #373 from anoma/brent/circ-supply

Circulating supply

Author: grarco

swagger.yml

@@ -798,6 +798,24 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/TokenSupply"
+  /api/v1/chain/circulating-supply:
+    get:
+      summary: Get the circulating supply of the native token at the given epoch
+      description: Calculates circulating supply by subtracting locked amounts from multiple excluded addresses from the effective supply
+      parameters:
+        - in: query
+          name: epoch
+          schema:
+            type: integer
+            minimum: 0
+          description: Epoch to query
+      responses:
+        "200":
+          description: Circulating supply of the native token
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/CirculatingSupply"
   /api/v1/chain/parameters:
     get:
       summary: Get chain parameters
@@ -1295,6 +1313,13 @@ components:
           type: string
         effectiveSupply:
           type: string
+    CirculatingSupply:
+      type: object
+      required: [circulatingSupply]
+      properties:
+        circulatingSupply:
+          type: string
+          description: Circulating supply of the native token (effective supply minus locked supply)
     Parameters:
       type: object
       required:

webserver/src/app.rs

@@ -144,6 +144,10 @@ impl ApplicationServer {
                     "/chain/token-supply",
                     get(chain_handlers::get_token_supply),
                 )
+                .route(
+                    "/chain/circulating-supply",
+                    get(chain_handlers::get_circulating_supply),
+                )
                 .route(
                     "/chain/block/latest",
                     get(chain_handlers::get_last_processed_block),

webserver/src/dto/chain.rs

@@ -8,3 +8,10 @@ pub struct TokenSupply {
     pub epoch: Option<i32>,
     pub address: String,
 }
+
+#[derive(Clone, Serialize, Deserialize, Validate)]
+#[serde(rename_all = "camelCase")]
+pub struct CirculatingSupply {
+    #[validate(range(min = 0))]
+    pub epoch: Option<i32>,
+}

webserver/src/handler/chain.rs

@@ -10,10 +10,13 @@ use axum_extra::extract::Query;
 use futures::Stream;
 use tokio_stream::StreamExt;
 
-use crate::dto::chain::TokenSupply as TokenSupplyDto;
+use crate::dto::chain::{
+    CirculatingSupply as CirculatingSupplyDto, TokenSupply as TokenSupplyDto,
+};
 use crate::error::api::ApiError;
 use crate::response::chain::{
-    LastProcessedBlock, LastProcessedEpoch, Parameters, RpcUrl, Token,
+    CirculatingSupply as CirculatingSupplyRsp, LastProcessedBlock,
+    LastProcessedEpoch, Parameters, RpcUrl, Token,
     TokenSupply as TokenSupplyRsp,
 };
 use crate::state::common::CommonState;
@@ -113,3 +116,14 @@ pub async fn get_token_supply(
         .await?;
     Ok(Json(supply))
 }
+
+pub async fn get_circulating_supply(
+    Query(query): Query<CirculatingSupplyDto>,
+    State(state): State<CommonState>,
+) -> Result<Json<CirculatingSupplyRsp>, ApiError> {
+    let supply = state
+        .chain_service
+        .get_circulating_supply(query.epoch)
+        .await?;
+    Ok(Json(supply))
+}

webserver/src/response/chain.rs

@@ -113,3 +113,9 @@ pub struct TokenSupply {
     pub total_supply: String,
     pub effective_supply: Option<String>,
 }
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CirculatingSupply {
+    pub circulating_supply: String,
+}

webserver/src/service/chain.rs

@@ -1,10 +1,12 @@
+use bigdecimal::BigDecimal;
 use shared::id::Id;
 use shared::token::{IbcToken, Token};
 
 use crate::appstate::AppState;
 use crate::error::chain::ChainError;
+use crate::repository::balance::{BalanceRepo, BalanceRepoTrait};
 use crate::repository::chain::{ChainRepository, ChainRepositoryTrait};
-use crate::response::chain::{Parameters, TokenSupply};
+use crate::response::chain::{CirculatingSupply, Parameters, TokenSupply};
 
 #[derive(Clone)]
 pub struct ChainService {
@@ -83,4 +85,65 @@ impl ChainService {
             effective_supply: supply.effective.map(|s| s.to_string()),
         }))
     }
+
+    pub async fn get_circulating_supply(
+        &self,
+        epoch: Option<i32>,
+    ) -> Result<CirculatingSupply, ChainError> {
+        // Native token address and addresses to exclude from circulating supply
+        let native_token_address =
+            "tnam1q9gr66cvu4hrzm0sd5kmlnjje82gs3xlfg3v6nu7";
+        let excluded_addresses = vec![
+            "tnam1qxdzup2hcvhswcgw5kerd5lfkf04t64y3scgqm5v",
+            "tnam1qxt7uxhj9r00mfm4u870e7ghz6j20jrdz58gm5kj",
+            "tnam1qyez9fd9nkaxfj4u2f2k0vavr8mm69azcgds45rr",
+            "tnam1qqp69rzwsgnqdm0d4qfhw4qa4s6v3tlzm5069f4j",
+            "tnam1qrucghh3hw2zq8xtqzdj44nh5nrmnkn0usqng8yq",
+        ];
+
+        // Get total supply of native token
+        let total_supply_result = self
+            .chain_repo
+            .get_token_supply(native_token_address.to_string(), epoch)
+            .await
+            .map_err(ChainError::Database)?;
+
+        let total_supply = total_supply_result.ok_or_else(|| {
+            ChainError::Unknown("Native token supply not found".to_string())
+        })?;
+
+        // Get balances for all excluded addresses and sum them up
+        let balance_repo = BalanceRepo::new(self.chain_repo.app_state.clone());
+        let mut total_locked_amount = BigDecimal::from(0);
+
+        for address in excluded_addresses {
+            let balances = balance_repo
+                .get_address_balances(address.to_string())
+                .await
+                .map_err(ChainError::Database)?;
+
+            // Find the balance of the native token for this excluded address
+            let locked_amount = balances
+                .iter()
+                .find(|balance| balance.token == native_token_address)
+                .map(|balance| balance.raw_amount.clone())
+                .unwrap_or_else(|| BigDecimal::from(0));
+
+            total_locked_amount += locked_amount;
+        }
+
+        // Calculate circulating supply = effective supply - total locked amount
+        let effective_supply_amount =
+            total_supply.effective.ok_or_else(|| {
+                ChainError::Unknown(
+                    "Effective supply not found for native token".to_string(),
+                )
+            })?;
+        let circulating_amount =
+            &effective_supply_amount - &total_locked_amount;
+
+        Ok(CirculatingSupply {
+            circulating_supply: circulating_amount.to_string(),
+        })
+    }
 }