unlocking stake for terra

components/Pages/Trade/Liquidity/hooks/useLockedPositions.ts

@@ -1,9 +1,10 @@
 import { useQuery } from 'react-query'
 
-import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate'
 import { useChain } from '@cosmos-kit/react-lite'
 import { PoolEntityType, TokenInfo } from 'components/Pages/Trade/Pools/hooks/usePoolsListQuery'
 import { useQueryPoolLiquidity } from 'components/Pages/Trade/Pools/hooks/useQueryPoolsLiquidity'
+import { WalletChainName } from 'constants/index'
 import { PositionState } from 'constants/state'
 import dayjs from 'dayjs'
 import { useClients } from 'hooks/useClients'
@@ -15,7 +16,7 @@ import { chainState } from 'state/chainState'
 import { protectAgainstNaN } from 'util/conversion/index'
 import { formatSeconds } from 'util/formatSeconds'
 
-import { useLiquidityAlliancePositions } from './useLiquidityAlliancePositions';
+import { useLiquidityAlliancePositions } from './useLiquidityAlliancePositions'
 
 export type Position = {
   poolId: string
@@ -40,12 +41,12 @@ export const lpPositionToAssets = ({
   protectAgainstNaN(totalAssets[1] * (myLockedLp / totalLpSupply)),
 ]
 export const fetchPositions = async (
-  poolId: string,
+  walletChainName: WalletChainName,
   cosmWasmClient: CosmWasmClient,
   prices: any,
   incentiveAddress: string,
   address: string,
-  pool_assets: any[],
+  poolAssets: any[],
   totalAssets: any,
   totalLpSupply: any,
   alliancePositions?: any,
@@ -61,65 +62,62 @@ export const fetchPositions = async (
     })
   }
   const allPositions = [...data.positions, ...alliancePositions || []]
-  const positions = allPositions.
-    map((p) => {
-      const positions = []
+  return allPositions.map((p) => {
+    const positions = []
 
-      // Open position
-      const open = { ...(p?.open_position || {}) }
-      open.formatedTime = formatSeconds(open.unbonding_duration)
-      open.isOpen = true
-      if (p?.open_position) {
-        positions.push(open)
-      }
+    // Open position
+    const open = { ...(p?.open_position || {}) }
+    open.formatedTime = formatSeconds(open.unbonding_duration)
+    open.isOpen = true
+    if (p?.open_position) {
+      positions.push(open)
+    }
 
-      // Closed position
-      const close = { ...(p?.closed_position || {}) }
-      const today = dayjs(new Date())
-      const unbonding = dayjs.unix(close.unbonding_timestamp)
-      const diff = unbonding.diff(today, 'second')
-      close.formatedTime = formatSeconds(diff)
-      close.isOpen = false
-      if (p?.closed_position) {
-        positions.push(close)
-      }
-      return positions.map((position) => {
-        const lpAssets = lpPositionToAssets({
-          totalAssets,
-          totalLpSupply,
-          myLockedLp: position.amount,
-        })
-        const assets = pool_assets.map((asset, i) => {
-          const assetAmount = fromChainAmount(lpAssets[i], asset.decimals)
-          const dollarValue = Number(assetAmount) * (prices?.[asset.symbol] || 0)
-          return {
-            ...asset,
-            amount: parseFloat(assetAmount),
-            dollarValue,
-          }
-        })
-        const isWithdraw = poolId === 'ampLUNA-LUNA' || poolId === 'bLUNA-LUNA' || poolId === 'WHALE-axlUSDC'
+    // Closed position
+    const close = { ...(p?.closed_position || {}) }
+    const today = dayjs(new Date())
+    const unbonding = dayjs.unix(close.unbonding_timestamp)
+    const diff = unbonding.diff(today, 'second')
+    close.formatedTime = formatSeconds(diff)
+    close.isOpen = false
+    if (p?.closed_position) {
+      positions.push(close)
+    }
+    return positions.map((position) => {
+      const lpAssets = lpPositionToAssets({
+        totalAssets,
+        totalLpSupply,
+        myLockedLp: position.amount,
+      })
+      const assets = poolAssets.map((asset, i) => {
+        const assetAmount = fromChainAmount(lpAssets[i], asset.decimals)
+        const dollarValue = Number(assetAmount) * (prices?.[asset.symbol] || 0)
         return {
-          ...position,
-          duration: position.isOpen ? (open.unbonding_duration == -1 ? 'Alliance' : position.formatedTime) : position.formatedTime,
-          weight: position.weight,
-          assets,
-          value: assets.reduce((acc, asset) => acc + Number(asset.dollarValue),
-            0),
-          state: position.isOpen
-            ? PositionState.active
-            : diff <= 0
-              ? PositionState.unbonded
-              : isWithdraw ? PositionState.withdraw : PositionState.unbonding,
-          action: null,
+          ...asset,
+          amount: parseFloat(assetAmount),
+          dollarValue,
         }
       })
-    }).
-    flat()
-  return positions
+      const isWithdraw = walletChainName === WalletChainName.terra
+      return {
+        ...position,
+        duration: position.isOpen ? (open.unbonding_duration === -1 ? 'Alliance' : position.formatedTime) : position.formatedTime,
+        weight: position.weight,
+        assets,
+        value: assets.reduce((acc, asset) => acc + Number(asset.dollarValue),
+          0),
+        state: position.isOpen
+          ? PositionState.active
+          : diff <= 0
+            ? PositionState.unbonded
+            : isWithdraw ? PositionState.withdraw : PositionState.unbonding,
+        action: null,
+      }
+    })
+  }).flat()
 }
 const useLockedPositions = (pool: PoolEntityType) => {
-  const [{ liquidity = {}, pool_assets = [] } = {}] =
+  const [{ liquidity = {}, pool_assets: poolAssets = [] } = {}] =
     useQueryPoolLiquidity({ poolId: pool?.pool_id })
   const { data: alliancePositions, isLoading } = useLiquidityAlliancePositions(pool?.lp_token)
   const totalLpSupply = liquidity?.available?.totalLpAmount || 0
@@ -137,17 +135,17 @@ const useLockedPositions = (pool: PoolEntityType) => {
       pool?.staking_address,
       pool?.pool_id,
       tokens,
-      pool_assets,
+      poolAssets,
       prices,
       alliancePositions,
     ],
     queryFn: (): Promise<Position[]> => fetchPositions(
-      pool?.pool_id,
+      walletChainName as WalletChainName,
       cosmWasmClient,
       prices,
       pool?.staking_address,
       address,
-      pool_assets,
+      poolAssets,
       totalReserve,
       totalLpSupply,
       alliancePositions,

hooks/useClients.ts

@@ -1,15 +1,15 @@
 import { useQueries } from 'react-query'
 
-import { GeneratedType, Registry } from '@cosmjs/proto-signing';
-import { AminoTypes } from '@cosmjs/stargate';
+import { GeneratedType, Registry } from '@cosmjs/proto-signing'
+import { AminoTypes } from '@cosmjs/stargate'
 import { useChain } from '@cosmos-kit/react-lite'
 import { InjectiveSigningStargateClient } from '@injectivelabs/sdk-ts/dist/cjs/core/stargate'
 import {
   cosmosAminoConverters,
   cosmosProtoRegistry,
   cosmwasmAminoConverters,
   cosmwasmProtoRegistry,
-} from '@nick134-bit/nicks-injectivejs/dist/codegen';
+} from '@nick134-bit/nicks-injectivejs/dist/codegen'
 
 export const useClients = (walletChainName: string) => {
   const {
@@ -56,14 +56,13 @@ export const useClients = (walletChainName: string) => {
           const registry: any = new Registry(protoRegistry);
           const aminoTypes = new AminoTypes(aminoConverters);
           const endpoint = await getRpcEndpoint()
-          const client = await InjectiveSigningStargateClient.connectWithSigner(
+          return await InjectiveSigningStargateClient.connectWithSigner(
             endpoint,
             offlineSigner, {
               registry,
               aminoTypes,
             },
           )
-          return client
         } catch {
           return null
         }