@sodax/wallet-sdk-react 0.0.1-rc.7 → 1.0.0-beta

package/src/SodaxWalletProvider.tsx

@@ -33,7 +33,7 @@ export const SodaxWalletProvider = ({ children, rpcConfig }: { children: React.R
   const wallets = useMemo(() => [new UnsafeBurnerWalletAdapter()], []);
 
   return (
-    <WagmiProvider config={wagmiConfig} reconnectOnMount={true}>
+    <WagmiProvider config={wagmiConfig}>
       <SuiClientProvider networks={{ mainnet: { url: getFullnodeUrl('mainnet') } }} defaultNetwork="mainnet">
         <SuiWalletProvider autoConnect={true}>
           <SolanaConnectionProvider endpoint={rpcConfig['solana'] ?? ''}>

package/src/core/XService.ts

@@ -45,7 +45,7 @@ export abstract class XService {
    * @param xTokens Array of tokens to get balances for
    * @returns Promise resolving to object mapping token addresses to balances
    */
-  public async getBalances(address: string | undefined, xTokens: XToken[]): Promise<Record<string, bigint>> {
+  public async getBalances(address: string | undefined, xTokens: readonly XToken[]): Promise<Record<string, bigint>> {
     if (!address) return {};
 
     const balancePromises = xTokens.map(async xToken => {

package/src/hooks/useXBalances.ts

@@ -44,7 +44,7 @@ export function useXBalances({
   xChainId,
   xTokens,
   address,
-}: { xChainId: ChainId; xTokens: XToken[]; address: string | undefined }): UseQueryResult<{
+}: { xChainId: ChainId; xTokens: readonly XToken[]; address: string | undefined }): UseQueryResult<{
   [key: string]: bigint;
 }> {
   const xService = useXService(getXChainType(xChainId));

package/src/xchains/evm/EvmXService.ts

@@ -1,22 +1,24 @@
 import { XService } from '@/core/XService';
-import type { RpcConfig, XToken } from '@sodax/types';
+import {
+  ARBITRUM_MAINNET_CHAIN_ID,
+  AVALANCHE_MAINNET_CHAIN_ID,
+  BASE_MAINNET_CHAIN_ID,
+  BSC_MAINNET_CHAIN_ID,
+  ETHEREUM_MAINNET_CHAIN_ID,
+  HYPEREVM_MAINNET_CHAIN_ID,
+  LIGHTLINK_MAINNET_CHAIN_ID,
+  OPTIMISM_MAINNET_CHAIN_ID,
+  POLYGON_MAINNET_CHAIN_ID,
+  SONIC_MAINNET_CHAIN_ID,
+  type RpcConfig,
+  type XToken,
+} from '@sodax/types';
 import { getWagmiChainId, isNativeToken } from '@/utils';
 
 import { type Address, defineChain, erc20Abi } from 'viem';
 import { getPublicClient } from 'wagmi/actions';
 import { type Config, createConfig, http } from 'wagmi';
-import {
-  mainnet,
-  avalanche,
-  base,
-  optimism,
-  polygon,
-  arbitrum,
-  bsc,
-  sonic,
-  nibiru,
-  lightlinkPhoenix,
-} from 'wagmi/chains';
+import { mainnet, avalanche, base, optimism, polygon, arbitrum, bsc, sonic, lightlinkPhoenix } from 'wagmi/chains';
 
 // HyperEVM chain is not supported by viem, so we need to define it manually
 export const hyper = /*#__PURE__*/ defineChain({
@@ -46,19 +48,19 @@ export const hyper = /*#__PURE__*/ defineChain({
 
 export const createWagmiConfig = (config: RpcConfig) => {
   return createConfig({
-    chains: [mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, nibiru, hyper, lightlinkPhoenix],
+    chains: [mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, hyper, lightlinkPhoenix],
+    ssr: true,
     transports: {
-      [mainnet.id]: http(config['mainnet']),
-      [avalanche.id]: http(config['avalanche']),
-      [arbitrum.id]: http(config['arbitrum']),
-      [base.id]: http(config['base']),
-      [bsc.id]: http(config['bsc']),
-      [sonic.id]: http(config['sonic']),
-      [optimism.id]: http(config['optimism']),
-      [polygon.id]: http(config['polygon']),
-      [nibiru.id]: http(config['nibiru']),
-      [hyper.id]: http(config['hyper']),
-      [lightlinkPhoenix.id]: http(config['lightlinkPhoenix']),
+      [mainnet.id]: http(config[ETHEREUM_MAINNET_CHAIN_ID]),
+      [avalanche.id]: http(config[AVALANCHE_MAINNET_CHAIN_ID]),
+      [arbitrum.id]: http(config[ARBITRUM_MAINNET_CHAIN_ID]),
+      [base.id]: http(config[BASE_MAINNET_CHAIN_ID]),
+      [bsc.id]: http(config[BSC_MAINNET_CHAIN_ID]),
+      [sonic.id]: http(config[SONIC_MAINNET_CHAIN_ID]),
+      [optimism.id]: http(config[OPTIMISM_MAINNET_CHAIN_ID]),
+      [polygon.id]: http(config[POLYGON_MAINNET_CHAIN_ID]),
+      [hyper.id]: http(config[HYPEREVM_MAINNET_CHAIN_ID]),
+      [lightlinkPhoenix.id]: http(config[LIGHTLINK_MAINNET_CHAIN_ID]),
     },
   });
 };

package/src/xchains/sui/SuiXService.ts

@@ -22,14 +22,10 @@ export class SuiXService extends XService {
 
   // getBalance is not used because getBalances uses getAllBalances which returns all balances
 
-  async getBalances(address: string | undefined, xTokens: XToken[]) {
+  async getBalances(address: string | undefined, xTokens: readonly XToken[]): Promise<Record<string, bigint>> {
     if (!address) return {};
-
     try {
-      const allBalances = await this.suiClient.getAllBalances({
-        owner: address,
-      });
-      const tokenMap = xTokens.reduce((map, xToken) => {
+      const balancePromises = xTokens.map(async xToken => {
         let coinType = isNativeToken(xToken) ? '0x2::sui::SUI' : xToken.address;
 
         //  TODO: hard coded for getting legacy bnUSD balance
@@ -41,11 +37,25 @@ export class SuiXService extends XService {
             '0x3917a812fe4a6d6bc779c5ab53f8a80ba741f8af04121193fc44e0f662e2ceb::balanced_dollar::BALANCED_DOLLAR';
         }
 
-        const balance = allBalances.find(b => b.coinType === coinType);
+        const balance = await this.suiClient.getBalance({
+          owner: address,
+          coinType: coinType,
+        });
+
+        return {
+          address: xToken.address,
+          balance: balance ? BigInt(balance.totalBalance) : undefined,
+        };
+      });
 
-        if (balance) map[xToken.address] = balance.totalBalance;
-        return map;
-      }, {});
+      const results = await Promise.all(balancePromises);
+
+      const tokenMap: Record<string, bigint> = {};
+      results.forEach(result => {
+        if (result.balance !== undefined) {
+          tokenMap[result.address] = result.balance;
+        }
+      });
 
       return tokenMap;
     } catch (e) {