fix: stopgap for transparent assets (#2299)

Author: neocybereth

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

@@ -17,24 +17,43 @@ export const getTotalDollar = (list?: TokenBalance[]): BigNumber =>
 export const getTotalNam = (list?: TokenBalance[]): BigNumber =>
   list?.find((i) => isNamadaAsset(i.asset))?.amount ?? new BigNumber(0);
 
+// Type to handle both balance data structures
+type BalanceItem = Balance | { tokenAddress: string; minDenomAmount: string };
+
 export const mapNamadaAddressesToAssets = ({
   balances,
   assets,
 }: {
-  balances: Balance[];
+  balances: BalanceItem[];
   assets: NamadaAsset[];
 }): Record<Address, NamadaAssetWithAmount> => {
   const map: Record<Address, NamadaAssetWithAmount> = {};
   balances.forEach((item) => {
-    const asset = assets.find((asset) => asset.address === item.token.address);
+    // Handle both data structures temporarily:
+    // 1. {token: {address: '...'}, minDenomAmount: '...'}
+    // 2. {tokenAddress: '...', minDenomAmount: '...'}
+    let tokenAddress: string | undefined;
+
+    if ("token" in item && item.token?.address) {
+      tokenAddress = item.token.address;
+    } else if ("tokenAddress" in item) {
+      tokenAddress = item.tokenAddress;
+    }
+
+    if (!tokenAddress) {
+      return;
+    }
+
+    const asset = assets.find((asset) => asset.address === tokenAddress);
 
     if (asset) {
-      map[item.token.address] = {
+      map[tokenAddress] = {
         amount: toDisplayAmount(asset, BigNumber(item.minDenomAmount)),
         asset,
       };
     }
   });
+
   return map;
 };
 

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

@@ -13,7 +13,6 @@ import { atomFamily } from "jotai/utils";
 import { isPublicKeyRevealed } from "lib/query";
 import isEqual from "lodash.isequal";
 import { TxKind } from "types/txKind";
-import { isNamadaAsset, toDisplayAmount } from "utils";
 import { fetchGasEstimate, fetchTokensGasPrice } from "./services";
 
 export type GasPriceTableItem = {
@@ -69,16 +68,12 @@ export const gasPriceTableAtom = atomWithQuery<GasPriceTable>((get) => {
       return (
         response
           // filter only tokens that exists on the chain
-          .filter(({ token }) => Boolean(chainAssetsMap.data[token.address]))
+          .filter(({ token }) => Boolean(chainAssetsMap.data[token]))
           .map(({ token, minDenomAmount }) => {
-            const asset = chainAssetsMap.data[token.address];
             const baseAmount = BigNumber(minDenomAmount);
+            // Transform string address to token object format
             return {
-              token,
-              gasPrice:
-                asset && isNamadaAsset(asset) ?
-                  toDisplayAmount(asset, baseAmount)
-                : baseAmount,
+              token: { address: token } as ApiV1ChainTokenGet200ResponseInner,
               gasPriceInMinDenom: baseAmount,
             };
           })

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

@@ -1,10 +1,13 @@
-import {
-  DefaultApi,
-  GasEstimate,
-  GasPriceTableInner,
-} from "@namada/indexer-client";
+import { DefaultApi, GasEstimate } from "@namada/indexer-client";
 import { TxKind } from "types/txKind";
 
+// Type for the actual API response - token is a string address
+// Note: The API type definition is incorrect (says it's an object), but server returns a string
+export type GasPriceResponse = {
+  token: string;
+  minDenomAmount: string;
+};
+
 export const fetchGasEstimate = async (
   api: DefaultApi,
   txKinds: TxKind[]
@@ -45,6 +48,9 @@ export const fetchGasEstimate = async (
 
 export const fetchTokensGasPrice = async (
   api: DefaultApi
-): Promise<GasPriceTableInner[]> => {
-  return (await api.apiV1GasPriceGet()).data;
+): Promise<GasPriceResponse[]> => {
+  const response = await api.apiV1GasPriceGet();
+  // The API type definition is wrong - it says token is an object, but server returns a string
+  // Cast the response to match the actual runtime data
+  return response.data as unknown as GasPriceResponse[];
 };

apps/namadillo/src/utils/gas.ts

@@ -2,7 +2,7 @@ import { isTransparentAddress } from "App/Transfer/common";
 import BigNumber from "bignumber.js";
 import namadaAssets from "chain-registry/mainnet/namada/assets";
 import { Address, Asset, GasConfig, GasConfigToDisplay } from "types";
-import { isNamadaAsset, toDisplayAmount } from "utils";
+import { toDisplayAmount } from "utils";
 import { unknownAsset } from "./assets";
 
 export const calculateGasFee = (gasConfig: GasConfig): BigNumber => {
@@ -35,12 +35,11 @@ export const getDisplayGasFee = (
       ) ?? unknownAsset(gasToken);
   }
 
-  const totalDisplayAmount = calculateGasFee(gasConfig);
+  const totalInMinDenom = calculateGasFee(gasConfig);
+  const totalDisplayAmount = toDisplayAmount(asset, totalInMinDenom);
+
   return {
-    totalDisplayAmount:
-      isNamadaAsset(asset) ? totalDisplayAmount : (
-        toDisplayAmount(asset, totalDisplayAmount).decimalPlaces(6)
-      ),
+    totalDisplayAmount: totalDisplayAmount.decimalPlaces(6),
     asset,
   };
 };