Revert "feat: pick gas fee token with enough balance" (#2213)

Author: mateuszjasiuk

apps/namadillo/src/App/Common/GasFeeModal.tsx

@@ -16,6 +16,7 @@ import { useAtomValue } from "jotai";
 import { IoClose } from "react-icons/io5";
 import { twMerge } from "tailwind-merge";
 import { Asset, GasConfig, NamadaAsset } from "types";
+import { toDisplayAmount } from "utils";
 import { getDisplayGasFee } from "utils/gas";
 import { FiatCurrency } from "./FiatCurrency";
 import { TokenCard } from "./TokenCard";
@@ -121,10 +122,17 @@ export const GasFeeModal = ({
 
   const findUserBalanceByTokenAddress = (tokenAddres: string): BigNumber => {
     // TODO: we need to refactor userShieldedBalances to return Balance[] type instead
-    const balances = isShielded ? shieldedAmount.data : transparentAmount.data;
+    const balances =
+      isShielded ?
+        shieldedAmount.data?.map((balance) => ({
+          minDenomAmount: balance.minDenomAmount,
+          tokenAddress: balance.address,
+        }))
+      : transparentAmount.data;
 
-    return BigNumber(
-      balances?.find((b) => b.tokenAddress === tokenAddres)?.amount || "0"
+    return new BigNumber(
+      balances?.find((token) => token.tokenAddress === tokenAddres)
+        ?.minDenomAmount || "0"
     );
   };
 
@@ -248,8 +256,9 @@ export const GasFeeModal = ({
                   gasToken: item.token,
                 });
 
-                const availableAmount = findUserBalanceByTokenAddress(
-                  item.token
+                const availableAmount = toDisplayAmount(
+                  asset,
+                  findUserBalanceByTokenAddress(item.token)
                 );
 
                 return {

apps/namadillo/src/atoms/accounts/atoms.ts

@@ -1,3 +1,4 @@
+import { Balance } from "@namada/indexer-client";
 import {
   AccountType,
   GenDisposableSignerResponse,
@@ -6,15 +7,13 @@ import {
 import { indexerApiAtom } from "atoms/api";
 import { nativeTokenAddressAtom } from "atoms/chain";
 import { shouldUpdateBalanceAtom } from "atoms/etc";
-import { namadaRegistryChainAssetsMapAtom } from "atoms/integrations";
 import { namadaExtensionConnectedAtom } from "atoms/settings";
 import { queryDependentFn } from "atoms/utils";
 import BigNumber from "bignumber.js";
 import { NamadaKeychain } from "hooks/useNamadaKeychain";
 import { atom } from "jotai";
 import { atomWithMutation, atomWithQuery } from "jotai-tanstack-query";
-import { Address } from "types";
-import { toDisplayAmount } from "utils";
+import { namadaAsset, toDisplayAmount } from "utils";
 import {
   fetchAccountBalance,
   fetchAccounts,
@@ -107,9 +106,9 @@ export const accountBalanceAtom = atomWithQuery<BigNumber>((get) => {
     ...queryDependentFn(async (): Promise<BigNumber> => {
       const balance = transparentBalanceQuery.data
         ?.filter(({ tokenAddress: ta }) => ta === tokenAddress.data)
-        .map(({ tokenAddress, amount }) => ({
+        .map(({ tokenAddress, minDenomAmount }) => ({
           token: tokenAddress,
-          amount,
+          amount: toDisplayAmount(namadaAsset(), new BigNumber(minDenomAmount)),
         }))
         .at(0);
       return balance ? BigNumber(balance.amount) : BigNumber(0);
@@ -137,35 +136,18 @@ export const disposableSignerAtom = atomWithQuery<GenDisposableSignerResponse>(
   }
 );
 
-export const transparentBalanceAtom = atomWithQuery<
-  { tokenAddress: Address; amount: BigNumber }[]
->((get) => {
+export const transparentBalanceAtom = atomWithQuery<Balance[]>((get) => {
   const enablePolling = get(shouldUpdateBalanceAtom);
   const api = get(indexerApiAtom);
   const defaultAccountQuery = get(defaultAccountAtom);
-  const assetsMapAtom = get(namadaRegistryChainAssetsMapAtom);
 
   const account = defaultAccountQuery.data;
-  const assetsMap = assetsMapAtom.data;
 
   return {
     refetchInterval: enablePolling ? 1000 : false,
     queryKey: ["transparent-balance", account],
     ...queryDependentFn(async () => {
-      if (!account || !assetsMap) {
-        return [];
-      }
-      const balance = await fetchAccountBalance(api, account);
-
-      return balance
-        .filter((b) => b.tokenAddress in assetsMap)
-        .map((item) => ({
-          tokenAddress: item.tokenAddress,
-          amount: toDisplayAmount(
-            assetsMap[item.tokenAddress],
-            BigNumber(item.minDenomAmount)
-          ),
-        }));
-    }, [defaultAccountQuery, assetsMapAtom]),
+      return account ? fetchAccountBalance(api, account) : [];
+    }, [defaultAccountQuery]),
   };
 });

apps/namadillo/src/atoms/balance/atoms.ts

@@ -20,12 +20,10 @@ import { maspIndexerUrlAtom, rpcUrlAtom } from "atoms/settings";
 import { queryDependentFn } from "atoms/utils";
 import { isAxiosError } from "axios";
 import BigNumber from "bignumber.js";
-import * as E from "fp-ts/Either";
 import { sequenceT } from "fp-ts/lib/Apply";
 import { pipe } from "fp-ts/lib/function";
 import * as O from "fp-ts/Option";
 import invariant from "invariant";
-import * as t from "io-ts";
 import { atom, getDefaultStore } from "jotai";
 import { atomWithQuery } from "jotai-tanstack-query";
 import { atomWithStorage } from "jotai/utils";
@@ -111,43 +109,12 @@ export const viewingKeysAtom = atomWithQuery<
   };
 });
 
-const NamadilloShieldedBalanceCodec = t.record(
-  t.string, // Address
-  t.array(
-    t.type({
-      tokenAddress: t.string,
-      amount: t.string,
-    })
-  )
-);
-
 export const storageShieldedBalanceAtom = atomWithStorage<
-  Record<Address, { tokenAddress: Address; amount: string }[]>
->(
-  "namadillo:shieldedBalance",
-  {},
-  {
-    // Invalidation function to ensure the stored data matches the codec
-    getItem(key, initialValue) {
-      const storedValue = localStorage.getItem(key);
-      const maybeValue = NamadilloShieldedBalanceCodec.decode(
-        JSON.parse(storedValue ?? "{}")
-      );
-
-      return E.isRight(maybeValue) ? maybeValue.right : initialValue;
-    },
-    setItem(key, value) {
-      localStorage.setItem(key, JSON.stringify(value));
-    },
-    removeItem(key) {
-      localStorage.removeItem(key);
-    },
-  }
-);
+  Record<Address, { address: Address; minDenomAmount: string }[]>
+>("namadillo:shieldedBalance", {});
 
 export const shieldedSyncProgress = atom(0);
 
-// After changing the stored data type, change the version in the key
 export const lastCompletedShieldedSyncAtom = atomWithStorage<
   Record<Address, Date | undefined>
 >("namadillo:last-shielded-sync", {}, undefined, { getOnInit: true });
@@ -165,13 +132,11 @@ export const shieldedBalanceAtom = atomWithQuery((get) => {
   const rpcUrl = get(rpcUrlAtom);
   const maspIndexerUrl = get(maspIndexerUrlAtom);
   const defaultAccount = get(defaultAccountAtom);
-  const assetsMapAtom = get(namadaRegistryChainAssetsMapAtom);
 
   const [viewingKey, allViewingKeys] = viewingKeysQuery.data ?? [];
   const chainTokens = chainTokensQuery.data?.map((t) => t.address);
   const chainId = chainParametersQuery.data?.chainId;
   const namTokenAddress = namTokenAddressQuery.data;
-  const assetsMap = assetsMapAtom.data;
 
   return {
     refetchInterval: enablePolling ? 1000 : false,
@@ -183,8 +148,7 @@ export const shieldedBalanceAtom = atomWithQuery((get) => {
         !chainTokens ||
         !chainId ||
         !namTokenAddress ||
-        !rpcUrl ||
-        !assetsMap
+        !rpcUrl
       ) {
         return [];
       }
@@ -204,24 +168,16 @@ export const shieldedBalanceAtom = atomWithQuery((get) => {
         chainTokens,
         chainId
       );
-      const shieldedBalance = response
-        // Filter out unknown assets
-        .filter(([address]) => address in assetsMap)
-        .map(([address, amount]) => {
-          const asset = assetsMap[address];
-          return {
-            tokenAddress: address,
-            amount: toDisplayAmount(asset, BigNumber(amount)),
-          };
-        });
+
+      const shieldedBalance = response.map(([address, amount]) => ({
+        address,
+        minDenomAmount: amount,
+      }));
 
       const storage = get(storageShieldedBalanceAtom);
       set(storageShieldedBalanceAtom, {
         ...storage,
-        [viewingKey.key]: shieldedBalance.map((balance) => ({
-          ...balance,
-          amount: balance.amount.toString(),
-        })),
+        [viewingKey.key]: shieldedBalance,
       });
 
       if (defaultAccount.data) {
@@ -242,7 +198,6 @@ export const shieldedBalanceAtom = atomWithQuery((get) => {
       chainTokensQuery,
       chainParametersQuery,
       namTokenAddressQuery,
-      assetsMapAtom,
     ]),
   };
 });
@@ -263,10 +218,8 @@ export const namadaShieldedAssetsAtom = atomWithQuery((get) => {
 
       return mapNamadaAddressesToAssets({
         balances:
-          shieldedBalance?.map((i) => ({
-            ...i,
-            amount: BigNumber(i.amount),
-          })) ?? [],
+          shieldedBalance?.map((i) => ({ ...i, tokenAddress: i.address })) ??
+          [],
         assets: Object.values(chainAssetsMap.data),
       });
     }, [viewingKeysQuery, chainTokensQuery, chainAssetsMap]),

apps/namadillo/src/atoms/balance/functions.ts

@@ -1,11 +1,12 @@
+import { Balance } from "@namada/indexer-client";
 import BigNumber from "bignumber.js";
 import {
   Address,
   NamadaAsset,
   NamadaAssetWithAmount,
   TokenBalance,
 } from "types";
-import { isNamadaAsset } from "utils";
+import { isNamadaAsset, toDisplayAmount } from "utils";
 
 export const getTotalDollar = (list?: TokenBalance[]): BigNumber =>
   (list ?? []).reduce(
@@ -20,16 +21,16 @@ export const mapNamadaAddressesToAssets = ({
   balances,
   assets,
 }: {
-  balances: { tokenAddress: Address; amount: BigNumber }[];
+  balances: Balance[];
   assets: NamadaAsset[];
 }): Record<Address, NamadaAssetWithAmount> => {
   const map: Record<Address, NamadaAssetWithAmount> = {};
-  balances.forEach(({ tokenAddress, amount }) => {
-    const asset = assets.find((asset) => asset.address === tokenAddress);
+  balances.forEach((item) => {
+    const asset = assets.find((asset) => asset.address === item.tokenAddress);
 
     if (asset) {
-      map[tokenAddress] = {
-        amount,
+      map[item.tokenAddress] = {
+        amount: toDisplayAmount(asset, BigNumber(item.minDenomAmount)),
         asset,
       };
     }

apps/namadillo/src/atoms/chain/atoms.ts

@@ -121,7 +121,7 @@ export const maspRewardsAtom = atomWithQuery((get) => {
     ...queryDependentFn(async (): Promise<MaspAssetRewards[]> => {
       invariant(chainAssetsMap.data, "No chain assets map");
 
-      return await fetchMaspRewards(chainAssetsMap.data);
+      return await fetchMaspRewards(Object.values(chainAssetsMap.data));
     }, [chainAssetsMap]),
   };
 });

apps/namadillo/src/atoms/chain/services.ts

@@ -4,8 +4,10 @@ import {
   NativeToken,
   Parameters,
 } from "@namada/indexer-client";
+import { getDenomFromIbcTrace } from "atoms/integrations";
 import BigNumber from "bignumber.js";
-import { Address, MaspAssetRewards, NamadaAsset } from "types";
+import { MaspAssetRewards, NamadaAsset } from "types";
+import { unknownAsset } from "utils/assets";
 import { getSdkInstance } from "utils/sdk";
 
 export const fetchRpcUrlFromIndexer = async (
@@ -41,16 +43,16 @@ export const clearShieldedContext = async (chainId: string): Promise<void> => {
 };
 
 export const fetchMaspRewards = async (
-  assets: Record<Address, NamadaAsset>
+  assets: NamadaAsset[]
 ): Promise<MaspAssetRewards[]> => {
   const sdk = await getSdkInstance();
   const rewards = await sdk.rpc.globalShieldedRewardForTokens();
-
   const existingRewards: MaspAssetRewards[] = rewards
-    .filter((r) => r.maxRewardRate > 0 && r.address in assets)
+    .filter((r) => r.maxRewardRate > 0)
     .map((r) => {
-      const asset = assets[r.address];
-
+      const denom = getDenomFromIbcTrace(r.name);
+      const asset =
+        assets.find((asset) => asset.base === denom) ?? unknownAsset(denom);
       return {
         asset,
         address: r.address,

apps/namadillo/src/atoms/fees/atoms.ts

@@ -11,7 +11,7 @@ import { isPublicKeyRevealed } from "lib/query";
 import isEqual from "lodash.isequal";
 import { Address } from "types";
 import { TxKind } from "types/txKind";
-import { toDisplayAmount } from "utils";
+import { isNamadaAsset, toDisplayAmount } from "utils";
 import { fetchGasEstimate, fetchTokensGasPrice } from "./services";
 
 export type GasPriceTableItem = {
@@ -73,7 +73,10 @@ export const gasPriceTableAtom = atomWithQuery<GasPriceTable>((get) => {
             const baseAmount = BigNumber(minDenomAmount);
             return {
               token,
-              gasPrice: toDisplayAmount(asset, baseAmount),
+              gasPrice:
+                asset && isNamadaAsset(asset) ?
+                  toDisplayAmount(asset, baseAmount)
+                : baseAmount,
             };
           })
       );

apps/namadillo/src/hooks/index.ts

@@ -1,3 +1,2 @@
 export * from "./useProposalIdParam";
 export * from "./useSdk";
-export * from "./useTransactionFee";

apps/namadillo/src/hooks/useOptimisticTransferUpdate.tsx

@@ -17,17 +17,17 @@ export const useOptimisticTransferUpdate = () => {
   const [viewingKeyData] = useAtomValue(viewingKeysAtom).data ?? [];
   const viewingKey = viewingKeyData?.key;
 
-  return (token: Address, incrementAmount: BigNumber) => {
+  return (token: Address, incrementBaseDenomAmount: BigNumber) => {
     if (!viewingKey) {
       return;
     }
     setStorageShieldedBalance((storage) => ({
       ...storage,
       [viewingKey]: storage[viewingKey].map((item) =>
-        item.tokenAddress === token ?
+        item.address === token ?
           {
             ...item,
-            amount: sum(item.amount, incrementAmount),
+            minDenomAmount: sum(item.minDenomAmount, incrementBaseDenomAmount),
           }
         : item
       ),