feat(app): tax and commision (#5208)

- **feat(app): add tax and commisions**
- **chore(app): fmt**
- **fix(app): use constant and get address dynamically from config**

Author: Swepool

app2/src/lib/services/incentive.ts

@@ -1,17 +1,15 @@
 /**
- * Incentive Service (WORK IN PROGRESS)
+ * Incentive Service
  *
- * Calculates staking incentives using:
- * - Total supply from cosmos bank module
- * - Inflation rate from cosmos mint module
- * - Bonded token supply from staking pool
- * - Community tax from distribution params
- *
- * Formula: Incentive = ((1 + [(inflation × total_supply ÷ bonded) × (1 − tax)] ÷ 365) ^ 365) − 1
+ * Calculates liquid staking incentives including:
+ * - Base staking rewards (inflation × total_supply ÷ bonded_tokens)
+ * - Community tax deduction
+ * - Validator commission deduction (weighted average from delegated validators)
  */
 
 import { HttpClient, HttpClientResponse } from "@effect/platform"
-import { BigDecimal, Data, Effect, pipe, Schema } from "effect"
+import { EU_STAKING_HUB } from "@unionlabs/sdk/Constants"
+import { Array, BigDecimal, Data, Effect, Option as O, pipe, Schema } from "effect"
 
 const REST_BASE_URL = "https://rest.union.build"
 
@@ -47,13 +45,61 @@ const CirculatingSupplyResponse = Schema.Struct({
   }),
 })
 
-// Schema for the incentive calculation result
+const ValidatorsResponse = Schema.Struct({
+  validators: Schema.Array(Schema.Struct({
+    operator_address: Schema.String,
+    tokens: Schema.BigDecimal,
+    commission: Schema.Struct({
+      commission_rates: Schema.Struct({
+        rate: Schema.BigDecimal,
+      }),
+    }),
+    status: Schema.String,
+    jailed: Schema.Boolean,
+  })),
+})
+
+const DelegatorDelegationsResponse = Schema.Struct({
+  delegation_responses: Schema.Array(Schema.Struct({
+    delegation: Schema.Struct({
+      delegator_address: Schema.String,
+      validator_address: Schema.String,
+      shares: Schema.BigDecimal,
+    }),
+    balance: Schema.Struct({
+      denom: Schema.String,
+      amount: Schema.BigDecimal,
+    }),
+  })),
+})
+
+const LstConfigResponse = Schema.Struct({
+  data: Schema.Struct({
+    staker_address: Schema.String,
+    native_token_denom: Schema.String,
+    minimum_liquid_stake_amount: Schema.String,
+    protocol_fee_config: Schema.Struct({
+      fee_rate: Schema.String,
+      fee_recipient: Schema.String,
+    }),
+    monitors: Schema.Array(Schema.String),
+    lst_address: Schema.String,
+    batch_period_seconds: Schema.Number,
+    unbonding_period_seconds: Schema.Number,
+    stopped: Schema.Boolean,
+  }),
+})
+
 export const IncentiveResult = Schema.Struct({
   rates: Schema.Struct({
     yearly: Schema.BigDecimalFromSelf,
   }),
   incentiveNominal: Schema.BigDecimalFromSelf,
   incentiveAfterTax: Schema.BigDecimalFromSelf,
+  incentiveAfterCommission: Schema.BigDecimalFromSelf,
+  communityTaxAmount: Schema.BigDecimalFromSelf,
+  validatorCommissionAmount: Schema.BigDecimalFromSelf,
+  weightedAverageCommission: Schema.BigDecimalFromSelf,
   inflation: Schema.BigDecimalFromSelf,
   totalSupply: Schema.BigDecimalFromSelf,
   bondedTokens: Schema.BigDecimalFromSelf,
@@ -131,17 +177,85 @@ const getCirculatingSupply = pipe(
   ),
 )
 
+const getValidators = pipe(
+  HttpClient.HttpClient,
+  Effect.map(HttpClient.withTracerDisabledWhen(() => true)),
+  Effect.andThen((client) =>
+    pipe(
+      client.get(`${REST_BASE_URL}/cosmos/staking/v1beta1/validators?status=BOND_STATUS_BONDED`),
+      Effect.flatMap(HttpClientResponse.schemaBodyJson(ValidatorsResponse)),
+      Effect.mapError((cause) =>
+        new IncentiveError({
+          message: "Failed to fetch validators",
+          cause,
+        })
+      ),
+    )
+  ),
+)
+
+const getLstConfig = pipe(
+  HttpClient.HttpClient,
+  Effect.map(HttpClient.withTracerDisabledWhen(() => true)),
+  Effect.andThen((client) => {
+    const queryMsg = btoa(JSON.stringify({ config: {} }))
+    return pipe(
+      client.get(
+        `${REST_BASE_URL}/cosmwasm/wasm/v1/contract/${EU_STAKING_HUB.address}/smart/${queryMsg}`,
+      ),
+      Effect.flatMap(HttpClientResponse.schemaBodyJson(LstConfigResponse)),
+      Effect.mapError((cause) =>
+        new IncentiveError({
+          message: "Failed to fetch LST contract config",
+          cause,
+        })
+      ),
+    )
+  }),
+)
+
+const getDelegatorDelegations = (delegatorAddress: string) =>
+  pipe(
+    HttpClient.HttpClient,
+    Effect.map(HttpClient.withTracerDisabledWhen(() => true)),
+    Effect.andThen((client) =>
+      pipe(
+        client.get(`${REST_BASE_URL}/cosmos/staking/v1beta1/delegations/${delegatorAddress}`),
+        Effect.flatMap(HttpClientResponse.schemaBodyJson(DelegatorDelegationsResponse)),
+        Effect.mapError((cause) =>
+          new IncentiveError({
+            message: "Failed to fetch delegator delegations",
+            cause,
+          })
+        ),
+      )
+    ),
+  )
+
 export const calculateIncentive: Effect.Effect<
   IncentiveResult,
   IncentiveError,
   HttpClient.HttpClient
 > = Effect.gen(function*() {
-  const [inflationData, stakingPoolData, distributionData, circulatingSupplyData] = yield* Effect
+  // First get the LST config to find the staker address
+  const lstConfig = yield* getLstConfig
+  const stakerAddress = lstConfig.data.staker_address
+
+  const [
+    inflationData,
+    stakingPoolData,
+    distributionData,
+    circulatingSupplyData,
+    validatorsData,
+    delegationsData,
+  ] = yield* Effect
     .all([
       getInflation,
       getStakingPool,
       getDistributionParams,
       getCirculatingSupply,
+      getValidators,
+      getDelegatorDelegations(stakerAddress),
     ], { concurrency: "unbounded" })
 
   const inflation = inflationData.inflation
@@ -181,7 +295,6 @@ export const calculateIncentive: Effect.Effect<
     )
   }
 
-  // Step 1: Calculate nominal incentive rate
   const incentiveNominal = yield* pipe(
     BigDecimal.multiply(inflation, totalSupply),
     BigDecimal.divide(bondedTokens),
@@ -192,11 +305,55 @@ export const calculateIncentive: Effect.Effect<
     ),
   )
 
-  // Step 2: Apply community tax
-  const incentiveAfterTax = BigDecimal.multiply(
-    incentiveNominal,
-    BigDecimal.subtract(BigDecimal.fromBigInt(1n), communityTax),
+  const communityTaxAmount = BigDecimal.multiply(incentiveNominal, communityTax)
+  const incentiveAfterTax = BigDecimal.subtract(incentiveNominal, communityTaxAmount)
+
+  // Calculate weighted average validator commission
+  const validDelegations = pipe(
+    delegationsData.delegation_responses,
+    Array.filterMap(delegation => {
+      const validator = pipe(
+        validatorsData.validators,
+        Array.findFirst(v => v.operator_address === delegation.delegation.validator_address),
+      )
+
+      return pipe(
+        validator,
+        O.filter(v => !v.jailed && v.status === "BOND_STATUS_BONDED"),
+        O.map(v => ({
+          amount: delegation.balance.amount,
+          commission: v.commission.commission_rates.rate,
+        })),
+      )
+    }),
+  )
+
+  const { totalAmount, weightedSum } = pipe(
+    validDelegations,
+    Array.reduce(
+      { totalAmount: BigDecimal.fromBigInt(0n), weightedSum: BigDecimal.fromBigInt(0n) },
+      (acc, { amount, commission }) => ({
+        totalAmount: BigDecimal.sum(acc.totalAmount, amount),
+        weightedSum: BigDecimal.sum(acc.weightedSum, BigDecimal.multiply(amount, commission)),
+      }),
+    ),
+  )
+
+  const weightedAverageCommission = BigDecimal.isZero(totalAmount)
+    ? BigDecimal.fromBigInt(0n)
+    : yield* BigDecimal.divide(weightedSum, totalAmount).pipe(
+      Effect.mapError(() =>
+        new IncentiveError({
+          message: "Could not calculate weighted average commission",
+        })
+      ),
+    )
+
+  const validatorCommissionAmount = BigDecimal.multiply(
+    incentiveAfterTax,
+    weightedAverageCommission,
   )
+  const incentiveAfterCommission = BigDecimal.subtract(incentiveAfterTax, validatorCommissionAmount)
 
   const bondedRatio = yield* BigDecimal.divide(bondedTokens, totalSupply).pipe(
     Effect.mapError(() =>
@@ -208,10 +365,14 @@ export const calculateIncentive: Effect.Effect<
 
   return {
     rates: {
-      yearly: incentiveAfterTax,
+      yearly: incentiveAfterCommission,
     },
     incentiveNominal,
     incentiveAfterTax,
+    incentiveAfterCommission,
+    communityTaxAmount,
+    validatorCommissionAmount,
+    weightedAverageCommission,
     inflation,
     totalSupply,
     bondedTokens,

app2/src/routes/stake/+page.svelte

@@ -129,7 +129,6 @@ AppRuntime.runPromiseExit$(() => {
 const incentives = AppRuntime.runPromiseExit$(() => {
   return Effect.gen(function*() {
     const incentive = yield* calculateIncentive
-    console.log("Incentive data loaded:", incentive)
     return incentive
   }).pipe(
     Effect.provide(FetchHttpClient.layer),