mini fixes

Author: arentant

apps/app/components/WalletProviders/Wagmi.tsx

@@ -87,7 +87,7 @@ function WagmiComponent({ children }: Props) {
         }
 
         cachedConfig = createConfig({
-            connectors: [...defaultConnectors],
+            connectors: typeof window === 'undefined' ? [] : [...defaultConnectors],
             chains: chains as [Chain, ...Chain[]],
             transports,
             ssr: true

apps/app/lib/balances/balanceResolver.ts

@@ -9,15 +9,8 @@ import {
     EVMBalanceProvider,
     FuelBalanceProvider,
     SolanaBalanceProvider,
-    StarknetBalanceProvider
-    //BitcoinBalanceProvider,
-    //LoopringBalanceProvider,
-    //ParadexBalanceProvider,
-    //QueryBalanceProvider,
-    //TonBalanceProvider,
-    //TronBalanceProvider,
-    //ZkSyncBalanceProvider,
-    //HyperliquidBalanceProvider
+    StarknetBalanceProvider,
+    TronBalanceProvider,
 } from "./providers";
 
 function formatErrorBalances(errorBalances: TokenBalance[]) {
@@ -42,19 +35,12 @@ function formatErrorBalances(errorBalances: TokenBalance[]) {
 export class BalanceResolver {
 
     private providers: BalanceProvider[] = [
-        // new QueryBalanceProvider(),
         new AztecBalanceProvider(),
         new EVMBalanceProvider(),
         new FuelBalanceProvider(),
-        // new LoopringBalanceProvider(),
         new SolanaBalanceProvider(),
         new StarknetBalanceProvider(),
-        // new TonBalanceProvider(),
-        // new ZkSyncBalanceProvider(),
-        // new TronBalanceProvider(),
-        // // new ParadexBalanceProvider(),
-        // new BitcoinBalanceProvider(),
-        // new HyperliquidBalanceProvider()
+        new TronBalanceProvider(),
     ];
 
     async getBalance(network: ExtendedNetwork, address?: string, options?: { timeoutMs?: number, retryCount?: number }): Promise<NetworkBalance> {

apps/app/lib/balances/providers/index.tsx

@@ -2,4 +2,5 @@ export { AztecBalanceProvider } from "./aztecBalanceProvider";
 export { EVMBalanceProvider } from "./evmBalanceProvider";
 export { FuelBalanceProvider } from "./fuelBalanceProvider";
 export { SolanaBalanceProvider } from "./solanaBalanceProvider";
-export { StarknetBalanceProvider } from "./starknetBalanceProvider";
+export { StarknetBalanceProvider } from "./starknetBalanceProvider";
+export { TronBalanceProvider } from "./tronBalanceProvider";

apps/app/lib/balances/providers/tonBalanceProvider.ts

@@ -0,0 +1,89 @@
+import { TokenBalance } from "../../../Models/Balance";
+import { Network, Token } from "../../../Models/Network";
+import { formatUnits } from "viem";
+import KnownInternalNames from "../../knownIds";
+import { TronWeb } from 'tronweb'
+import { insertIfNotExists } from "../helpers";
+import { BalanceProvider } from "@/Models/BalanceProvider";
+import { getNetworkRpcUrl } from "@/lib/rpc/resolveNetworkRpcUrl";
+
+export class TronBalanceProvider extends BalanceProvider {
+    supportsNetwork: BalanceProvider['supportsNetwork'] = (network) => {
+        return (KnownInternalNames.Networks.TronMainnet.includes(network.caip2Id) || KnownInternalNames.Networks.TronNile.includes(network.caip2Id))
+    }
+
+    fetchBalance: BalanceProvider['fetchBalance'] = async (address, network) => {
+        let balances: TokenBalance[] = []
+        const nodeUrl = getNetworkRpcUrl(network)
+
+        const provider = new TronWeb({ fullNode: nodeUrl, solidityNode: nodeUrl, privateKey: '01', });
+
+        for (const token of network.tokens) {
+            try {
+                const balance = await resolveBalance({ network, address, token, provider })
+
+                balances.push(balance)
+
+            }
+            catch (e) {
+                balances.push(this.resolveTokenBalanceFetchError(e, token, network))
+            }
+        }
+
+        return balances
+    }
+}
+
+type GetBalanceProps = {
+    network: Network,
+    token: Token,
+    address: string,
+    provider: TronWeb
+}
+
+export const resolveBalance = async ({ address, network, token, provider }: GetBalanceProps) => {
+
+    if (token.contract !== '0x0000000000000000000000000000000000000000') {
+        const res = await getTRC20Balance({ network, token, address, provider })
+        return res
+    }
+    else {
+        const res = await getNativeAssetBalance({ network, token, address, provider })
+        return res
+    }
+}
+
+const getNativeAssetBalance = async ({ network, token, address, provider }: GetBalanceProps) => {
+
+    const balance = await provider.trx.getBalance(address);
+
+    return ({
+        network: network.caip2Id,
+        token: token.symbol,
+        amount: Number(formatUnits(BigInt(balance.toString()), Number(token?.decimals))),
+        request_time: new Date().toJSON(),
+        decimals: Number(token?.decimals),
+        isNativeCurrency: true,
+    })
+
+}
+
+const getTRC20Balance = async ({ network, token, address, provider }: GetBalanceProps) => {
+    if (!token.contract) throw new Error("Token contract address is missing")
+
+    const tokenContractAddress = token.contract;
+    const contract = await provider.contract().at(tokenContractAddress);
+
+    const balanceResponse = await contract.methods.balanceOf(address).call();
+
+    const balance = {
+        network: network.caip2Id,
+        token: token.symbol,
+        amount: Number(formatUnits(BigInt(balanceResponse as any), token.decimals)),
+        request_time: new Date().toJSON(),
+        decimals: token.decimals,
+        isNativeCurrency: false,
+    }
+
+    return balance
+}

apps/app/lib/balances/providers/tronBalanceProvider.ts

@@ -16,7 +16,7 @@ export default class KnownInternalNames {
 
         public static readonly TronMainnet: string = "TRON_MAINNET"
 
-        public static readonly TronTestnet: string = "tron:3448148188"
+        public static readonly TronNile: string = "tron:3448148188"
 
         public static readonly CronosMainnet: string = "CRONOS_MAINNET";
 

apps/app/lib/balances/providers/zkSyncBalanceProvider.ts

@@ -259,6 +259,7 @@ export function walletConnect(parameters: Params) {
             return provider.accounts.map((x: string) => getAddress(x))
         },
         async getProvider({ chainId } = {}) {
+            if (typeof window === 'undefined') return undefined as unknown as Provider
             async function initProvider() {
                 const optionalChains = config.chains.map((x) => x.id) as [number]
                 if (!optionalChains.length) return

apps/app/lib/knownIds.ts

@@ -10,7 +10,7 @@ const id = 'tron'
 
 const commonSupportedNetworks = [
     KnownInternalNames.Networks.TronMainnet,
-    KnownInternalNames.Networks.TronTestnet
+    KnownInternalNames.Networks.TronNile
 ]
 
 export default function useTron(): WalletProvider {

apps/app/lib/wallets/evm/connectors/walletConnect.ts

@@ -78,7 +78,7 @@
     "@walletconnect/types": "2.21.8",
     "@walletconnect/universal-provider": "2.21.8",
     "@walletconnect/utils": "2.21.8",
-    "axios": "1.14.0",
+    "axios": "1.16.0",
     "bn.js": "^5.2.0",
     "bs58": "^6.0.0",
     "class-variance-authority": "^0.7.1",