@sodax/wallet-sdk-react 1.5.7-beta → 2.0.0-rc.1

package/src/xchains/evm/EvmXService.ts

@@ -1,211 +0,0 @@
-import { XService } from '@/core/XService';
-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,
-  KAIA_MAINNET_CHAIN_ID,
-  LIGHTLINK_MAINNET_CHAIN_ID,
-  OPTIMISM_MAINNET_CHAIN_ID,
-  POLYGON_MAINNET_CHAIN_ID,
-  REDBELLY_MAINNET_CHAIN_ID,
-  SONIC_MAINNET_CHAIN_ID,
-  type RpcConfig,
-  type XToken,
-} from '@sodax/types';
-import { getWagmiChainId, isNativeToken } from '@/utils';
-
-import { type Address, type Chain, defineChain, erc20Abi } from 'viem';
-import { getPublicClient } from 'wagmi/actions';
-import { type Config, createConfig, http, createStorage, cookieStorage } from 'wagmi';
-import {
-  mainnet,
-  avalanche,
-  base,
-  optimism,
-  polygon,
-  arbitrum,
-  bsc,
-  sonic,
-  lightlinkPhoenix,
-  redbellyMainnet,
-  kaia,
-} from 'wagmi/chains';
-import type { WagmiOptions } from '@/SodaxWalletProvider';
-
-// HyperEVM chain is not supported by viem, so we need to define it manually
-export const hyper = /*#__PURE__*/ defineChain({
-  id: 999,
-  name: 'HyperEVM',
-  nativeCurrency: {
-    decimals: 18,
-    name: 'HYPE',
-    symbol: 'HYPE',
-  },
-  rpcUrls: {
-    default: { http: ['https://rpc.hyperliquid.xyz/evm'] },
-  },
-  blockExplorers: {
-    default: {
-      name: 'HyperEVMScan',
-      url: 'https://hyperevmscan.io/',
-    },
-  },
-  contracts: {
-    multicall3: {
-      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
-      blockCreated: 13051,
-    },
-  },
-});
-
-export const createWagmiConfig = (config: RpcConfig, options?: WagmiOptions) => {
-  return createConfig({
-    chains: [
-      mainnet,
-      avalanche,
-      arbitrum,
-      base,
-      bsc,
-      sonic,
-      optimism,
-      polygon,
-      hyper,
-      lightlinkPhoenix,
-      kaia,
-      redbellyMainnet,
-    ],
-    ssr: options?.ssr,
-    transports: {
-      [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]),
-      [redbellyMainnet.id]: http(config[REDBELLY_MAINNET_CHAIN_ID]),
-      [kaia.id]: http(config[KAIA_MAINNET_CHAIN_ID]),
-    },
-    storage: createStorage({
-      storage: cookieStorage,
-      key: 'sodax',
-    }),
-  });
-};
-
-/**
- * Service class for handling EVM chain interactions.
- * Implements singleton pattern and provides methods for wallet/chain operations.
- */
-
-export class EvmXService extends XService {
-  private static instance: EvmXService;
-  public wagmiConfig: Config | undefined;
-
-  private constructor() {
-    super('EVM');
-  }
-
-  getXConnectors() {
-    return [];
-  }
-
-  public static getInstance(): EvmXService {
-    if (!EvmXService.instance) {
-      EvmXService.instance = new EvmXService();
-    }
-    return EvmXService.instance;
-  }
-
-  // get erc20 token balance in a chain (evm chain only)
-  async _getTokenBalance(address: string | undefined, chainId: number, tokenAddress: string): Promise<bigint> {
-    const publicClient = getPublicClient(this.wagmiConfig as Config, { chainId: chainId });
-    if (!publicClient) throw new Error('Public client not found');
-    const balance = await publicClient.readContract({
-      abi: erc20Abi,
-      address: tokenAddress as `0x${string}`,
-      functionName: 'balanceOf',
-      args: [address as `0x${string}`],
-    });
-    return balance || 0n;
-  }
-
-  //get native balance of the chain (evm chain only)
-  async _getChainBalance(address: string | undefined, chainId: number) {
-    const balance = await getPublicClient(this.wagmiConfig as Config, { chainId: chainId })?.getBalance({
-      address: address as Address,
-    });
-    return balance || 0n;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
-    if (!address) return 0n;
-    if (!this.wagmiConfig) return 0n;
-
-    const chainId = getWagmiChainId(xToken.xChainId);
-
-    if (isNativeToken(xToken)) {
-      return this._getChainBalance(address, chainId);
-    }
-
-    throw new Error(`Unsupported token: ${xToken.symbol}`);
-  }
-
-  async getBalances(address: string | undefined, xTokens: XToken[]) {
-    if (!address) return {};
-    if (!this.wagmiConfig) return {};
-
-    const nativeTokenBalancePromises = xTokens
-      .filter(xToken => isNativeToken(xToken))
-      .map(async xToken => {
-        const balance = await this.getBalance(address, xToken);
-        return { symbol: xToken.symbol, address: xToken.address, balance };
-      });
-
-    const nativeTokenBalances = await Promise.all(nativeTokenBalancePromises);
-    const tokenMap = nativeTokenBalances.reduce((map, { address, balance }) => {
-      if (balance) map[address] = balance;
-      return map;
-    }, {});
-
-    const nonNativeXTokens = xTokens.filter(xToken => !isNativeToken(xToken));
-    const xChainId = xTokens[0].xChainId;
-    const viemChain: Chain = this.wagmiConfig.chains.find(chain => chain.id === getWagmiChainId(xChainId)) as Chain;
-    const chainId = getWagmiChainId(xChainId);
-
-    const publicClient = getPublicClient(this.wagmiConfig, { chainId: chainId });
-    if (!publicClient) throw new Error('Public client not found');
-
-    if (viemChain?.contracts?.multicall3) {
-      //multicall supports
-      const result = await publicClient.multicall({
-        contracts: nonNativeXTokens.map(token => ({
-          abi: erc20Abi,
-          address: token.address as `0x${string}`,
-          functionName: 'balanceOf',
-          args: [address],
-        })),
-      });
-
-      return nonNativeXTokens.reduce((acc, token, index) => {
-        acc[token.address] = result?.[index]?.result?.toString() || '0';
-        return acc;
-      }, tokenMap);
-    }
-
-    const nonNativeTokenBalances: bigint[] = await Promise.all(
-      nonNativeXTokens.map(token => this._getTokenBalance(address, chainId, token.address)),
-    );
-
-    return nonNativeXTokens.reduce((acc, token, idx) => {
-      acc[token.address] = nonNativeTokenBalances[idx] || '0';
-      return acc;
-    }, tokenMap);
-  }
-}

package/src/xchains/evm/index.ts

@@ -1,3 +0,0 @@
-export { EvmXService } from './EvmXService';
-export { EvmXConnector } from './EvmXConnector';
-export { createWagmiConfig, createWagmiConfig as createWagmi } from './EvmXService';

package/src/xchains/icon/IconHanaXConnector.ts

@@ -1,39 +0,0 @@
-import type { XAccount } from '@/types';
-import { ICONexRequestEventType, ICONexResponseEventType, request } from './iconex';
-
-import { XConnector } from '@/core/XConnector';
-
-export class IconHanaXConnector extends XConnector {
-  constructor() {
-    super('ICON', 'Hana Wallet', 'hana');
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    const { hanaWallet } = window as any;
-    if (window && !hanaWallet && !hanaWallet?.isAvailable) {
-      window.open('https://chromewebstore.google.com/detail/hana-wallet/jfdlamikmbghhapbgfoogdffldioobgl', '_blank');
-      return;
-    }
-
-    const detail = await request({
-      type: ICONexRequestEventType.REQUEST_ADDRESS,
-    });
-
-    if (detail?.type === ICONexResponseEventType.RESPONSE_ADDRESS) {
-      return {
-        address: detail?.payload,
-        xChainType: this.xChainType,
-      };
-    }
-
-    return undefined;
-  }
-
-  async disconnect(): Promise<void> {
-    console.log('HanaIconXConnector disconnected');
-  }
-
-  public get icon() {
-    return 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg';
-  }
-}

package/src/xchains/icon/IconXService.ts

@@ -1,117 +0,0 @@
-import { XService } from '@/core/XService';
-import type { IconService } from 'icon-sdk-js';
-import * as IconSdkRaw from 'icon-sdk-js';
-import type { XToken } from '@sodax/types';
-import { isNativeToken } from '@/utils';
-
-const IconSdk = ('default' in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw) as typeof IconSdkRaw;
-const { IconService: IconServiceConstructor, Builder: IconBuilder, Converter: IconConverter } = IconSdk;
-export interface CallData {
-  target: string;
-  method: string;
-  params: string[];
-}
-
-export enum SupportedChainId {
-  MAINNET = 1,
-}
-
-interface ChainInfo {
-  readonly name: string;
-  readonly node: string;
-  readonly APIEndpoint: string;
-  readonly debugAPIEndpoint: string;
-  readonly chainId: number;
-  readonly tracker: string;
-}
-
-export const CHAIN_INFO: { readonly [chainId: number]: ChainInfo } = {
-  [SupportedChainId.MAINNET]: {
-    name: 'ICON Mainnet',
-    node: 'https://ctz.solidwallet.io',
-    APIEndpoint: 'https://ctz.solidwallet.io/api/v3',
-    debugAPIEndpoint: 'https://api.icon.community/api/v3d',
-    chainId: 1,
-    tracker: 'https://tracker.icon.community',
-  },
-};
-
-export class IconXService extends XService {
-  private static instance: IconXService;
-
-  public iconService: IconService;
-
-  private constructor() {
-    super('ICON');
-    this.iconService = new IconServiceConstructor(
-      new IconServiceConstructor.HttpProvider(CHAIN_INFO[SupportedChainId.MAINNET].APIEndpoint),
-    );
-  }
-
-  public static getInstance(): IconXService {
-    if (!IconXService.instance) {
-      IconXService.instance = new IconXService();
-    }
-    return IconXService.instance;
-  }
-
-  private async getAggregateData(requireSuccess: boolean, calls: CallData[]) {
-    const rawTx = new IconBuilder.CallBuilder()
-      // muticall address on mainnet
-      .to('cxa4aa9185e23558cff990f494c1fd2845f6cbf741')
-      .method('tryAggregate')
-      .params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls })
-      .build();
-
-    try {
-      const result = await this.iconService.call(rawTx).execute();
-      const aggs = result['returnData'];
-
-      const data = aggs.map(agg => {
-        if (agg['success'] === '0x0') {
-          return null;
-        }
-        return agg['returnData'];
-      });
-
-      return data;
-    } catch (err) {
-      console.error(err);
-      return Array(calls.length).fill(null);
-    }
-  }
-
-  async getBalances(address: string | undefined, xTokens: XToken[]) {
-    if (!address) return {};
-
-    const balances = {};
-
-    const nativeXToken = xTokens.find(xToken => isNativeToken(xToken));
-    const nonNativeXTokens = xTokens.filter(xToken => !isNativeToken(xToken));
-
-    if (nativeXToken) {
-      const balance = await this.iconService.getBalance(address).execute();
-      balances[nativeXToken.address] = BigInt(balance.toFixed());
-    }
-
-    const cds: CallData[] = nonNativeXTokens.map(token => {
-      return {
-        target: token.address,
-        method: 'balanceOf',
-        params: [address],
-      };
-    });
-
-    const data: string[] = await this.getAggregateData(
-      false,
-      cds.filter(cd => cd.target.startsWith('cx')),
-    );
-
-    return nonNativeXTokens.reduce((agg, token, idx) => {
-      const balance = data[idx];
-      balances[token.address] = BigInt(balance);
-
-      return agg;
-    }, balances);
-  }
-}

package/src/xchains/icon/actions.ts

@@ -1,28 +0,0 @@
-import { useXWagmiStore } from '@/useXWagmiStore';
-import { ICONexRequestEventType, ICONexResponseEventType, request } from './iconex';
-
-export const reconnectIcon = async () => {
-  const iconConnection = useXWagmiStore.getState().xConnections.ICON;
-  if (!iconConnection) return;
-
-  const recentXConnectorId = iconConnection.xConnectorId;
-
-  const detail = await request({
-    type: ICONexRequestEventType.REQUEST_ADDRESS,
-  });
-
-  if (detail?.type === ICONexResponseEventType.RESPONSE_ADDRESS) {
-    useXWagmiStore.setState({
-      xConnections: {
-        ...useXWagmiStore.getState().xConnections,
-        ICON: {
-          xAccount: {
-            address: detail?.payload,
-            xChainType: 'ICON',
-          },
-          xConnectorId: recentXConnectorId,
-        },
-      },
-    });
-  }
-};

package/src/xchains/icon/iconex/index.tsx

@@ -1,46 +0,0 @@
-const ICONEX_RELAY_RESPONSE = 'ICONEX_RELAY_RESPONSE';
-const ICONEX_RELAY_REQUEST = 'ICONEX_RELAY_REQUEST';
-
-export enum ICONexRequestEventType {
-  REQUEST_HAS_ACCOUNT = 'REQUEST_HAS_ACCOUNT',
-  REQUEST_HAS_ADDRESS = 'REQUEST_HAS_ADDRESS',
-  REQUEST_ADDRESS = 'REQUEST_ADDRESS',
-  REQUEST_JSON = 'REQUEST_JSON',
-  REQUEST_SIGNING = 'REQUEST_SIGNING',
-}
-
-export enum ICONexResponseEventType {
-  RESPONSE_HAS_ACCOUNT = 'RESPONSE_HAS_ACCOUNT',
-  RESPONSE_HAS_ADDRESS = 'RESPONSE_HAS_ADDRESS',
-  RESPONSE_ADDRESS = 'RESPONSE_ADDRESS',
-  RESPONSE_JSON = 'RESPONSE_JSON',
-  RESPONSE_SIGNING = 'RESPONSE_SIGNING',
-}
-
-export interface ICONexRequestEvent {
-  type: ICONexRequestEventType;
-  payload?: any;
-}
-
-export interface ICONexResponseEvent {
-  type: ICONexResponseEventType;
-  payload?: any;
-}
-
-export type ICONexEvent = ICONexRequestEvent | ICONexResponseEvent;
-
-export const request = (event: ICONexRequestEvent): Promise<ICONexResponseEvent> => {
-  return new Promise((resolve, reject) => {
-    const handler = evt => {
-      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
-      resolve(evt.detail);
-    };
-
-    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
-    window.dispatchEvent(
-      new CustomEvent(ICONEX_RELAY_REQUEST, {
-        detail: event,
-      }),
-    );
-  });
-};

package/src/xchains/icon/index.ts

@@ -1,2 +0,0 @@
-export { IconXService } from './IconXService';
-export { IconHanaXConnector } from './IconHanaXConnector';

package/src/xchains/injective/InjectiveXConnector.ts

@@ -1,60 +0,0 @@
-import type { XAccount } from '@/types';
-import { XConnector } from '@/core';
-import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
-import { type Wallet, isEvmBrowserWallet, isCosmosBrowserWallet } from '@injectivelabs/wallet-base';
-import { isCosmosWalletInstalled } from '@injectivelabs/wallet-cosmos';
-import { InjectiveXService } from './InjectiveXService';
-
-const WALLET_ICONS: Partial<Record<Wallet, string>> = {
-  metamask: 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/metamask.svg',
-  keplr: 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/keplr.svg',
-  leap: 'https://assets.leapwallet.io/logos/leap-cosmos-logo.svg',
-  rabby: 'https://raw.githubusercontent.com/RabbyHub/logo/master/symbol.svg',
-  phantom: 'https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/phantom.svg',
-  'okx-wallet': 'https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png',
-  'trust-wallet': 'https://trustwallet.com/assets/images/media/assets/twLogo.svg',
-};
-
-export class InjectiveXConnector extends XConnector {
-  private wallet: Wallet;
-
-  constructor(name: string, wallet: Wallet) {
-    super('INJECTIVE', name, wallet);
-    this.wallet = wallet;
-  }
-
-  getXService(): InjectiveXService {
-    return InjectiveXService.getInstance();
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    if (isCosmosBrowserWallet(this.wallet) && !isCosmosWalletInstalled(this.wallet)) {
-      return undefined;
-    }
-
-    const walletStrategy = this.getXService().walletStrategy;
-    await walletStrategy.setWallet(this.wallet);
-    const addresses = await walletStrategy.getAddresses();
-
-    if (!addresses?.length) return undefined;
-
-    const address = isEvmBrowserWallet(this.wallet) ? getInjectiveAddress(addresses[0]) : addresses[0];
-
-    return {
-      address,
-      xChainType: this.xChainType,
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    if (isEvmBrowserWallet(this.wallet)) {
-      const walletStrategy = this.getXService().walletStrategy;
-      await walletStrategy.setWallet(this.wallet);
-      await walletStrategy.disconnect();
-    }
-  }
-
-  public get icon(): string | undefined {
-    return WALLET_ICONS[this.wallet];
-  }
-}

package/src/xchains/injective/InjectiveXService.ts

@@ -1,62 +0,0 @@
-import { XService } from '@/core/XService';
-import { Network, getNetworkEndpoints } from '@injectivelabs/networks';
-import { ChainGrpcWasmApi, IndexerGrpcAccountPortfolioApi } from '@injectivelabs/sdk-ts';
-import { ChainId as InjectiveChainId } from '@injectivelabs/ts-types';
-import { MsgBroadcaster } from '@injectivelabs/wallet-core';
-import type { XToken } from '@sodax/types';
-import { mainnet } from 'wagmi/chains';
-import { WalletStrategy } from '@injectivelabs/wallet-strategy';
-
-export class InjectiveXService extends XService {
-  private static instance: InjectiveXService;
-
-  public walletStrategy: WalletStrategy;
-  public indexerGrpcAccountPortfolioApi: IndexerGrpcAccountPortfolioApi;
-  public chainGrpcWasmApi: ChainGrpcWasmApi;
-  public msgBroadcaster: MsgBroadcaster;
-
-  private constructor() {
-    super('INJECTIVE');
-
-    const endpoints = getNetworkEndpoints(Network.Mainnet);
-
-    this.walletStrategy = new WalletStrategy({
-      chainId: InjectiveChainId.Mainnet,
-      strategies: {},
-      evmOptions: {
-        evmChainId: mainnet.id,
-        rpcUrl: mainnet.rpcUrls.default.http[0],
-      },
-    });
-
-    this.indexerGrpcAccountPortfolioApi = new IndexerGrpcAccountPortfolioApi(endpoints.indexer);
-    this.chainGrpcWasmApi = new ChainGrpcWasmApi(endpoints.grpc);
-    this.msgBroadcaster = new MsgBroadcaster({
-      walletStrategy: this.walletStrategy,
-      network: Network.Mainnet,
-      endpoints,
-    });
-  }
-
-  public static getInstance(): InjectiveXService {
-    if (!InjectiveXService.instance) {
-      InjectiveXService.instance = new InjectiveXService();
-    }
-    return InjectiveXService.instance;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken) {
-    if (!address) return 0n;
-
-    const portfolio = await this.indexerGrpcAccountPortfolioApi.fetchAccountPortfolioBalances(address);
-
-    const xTokenAddress = xToken.address;
-
-    const balance = portfolio.bankBalancesList.find(_balance => _balance.denom === xTokenAddress);
-    if (balance) {
-      return BigInt(balance.amount);
-    }
-
-    return 0n;
-  }
-}

package/src/xchains/injective/actions.ts

@@ -1,32 +0,0 @@
-import { useXWagmiStore } from '@/useXWagmiStore';
-import { InjectiveXService } from './InjectiveXService';
-import { isEvmBrowserWallet } from '@injectivelabs/wallet-base';
-import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
-import type { Wallet } from '@injectivelabs/wallet-base';
-
-export const reconnectInjective = async () => {
-  const injectiveConnection = useXWagmiStore.getState().xConnections.INJECTIVE;
-  if (!injectiveConnection) return;
-
-  const recentXConnectorId = injectiveConnection.xConnectorId;
-  const walletStrategy = InjectiveXService.getInstance().walletStrategy;
-  await walletStrategy.setWallet(recentXConnectorId as Wallet);
-  const addresses = await walletStrategy.getAddresses();
-
-  const address = isEvmBrowserWallet(recentXConnectorId as Wallet)
-    ? getInjectiveAddress(addresses?.[0])
-    : addresses?.[0];
-
-  useXWagmiStore.setState({
-    xConnections: {
-      ...useXWagmiStore.getState().xConnections,
-      INJECTIVE: {
-        xAccount: {
-          address,
-          xChainType: 'INJECTIVE',
-        },
-        xConnectorId: recentXConnectorId,
-      },
-    },
-  });
-};

package/src/xchains/injective/index.ts

@@ -1,2 +0,0 @@
-export { InjectiveXService } from './InjectiveXService';
-export { InjectiveXConnector } from './InjectiveXConnector';

package/src/xchains/near/NearXConnector.ts

@@ -1,42 +0,0 @@
-import type { XAccount } from '@/types';
-
-import { XConnector } from '@/core';
-import type { NearWalletBase } from '@hot-labs/near-connect';
-import { NearXService } from './NearXService';
-
-export class NearXConnector extends XConnector {
-  _wallet: NearWalletBase;
-
-  constructor(wallet: NearWalletBase) {
-    super('NEAR', wallet.manifest.name, wallet.manifest.id);
-    this._wallet = wallet;
-  }
-
-  getXService(): NearXService {
-    return NearXService.getInstance();
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    const walletSelector = this.getXService().walletSelector;
-    const wallet = await walletSelector.connect({ walletId: this._wallet.manifest.id });
-    const accounts = await wallet.getAccounts();
-
-    if (accounts.length === 0 || accounts[0] === undefined) {
-      return undefined;
-    }
-
-    return {
-      address: accounts[0].accountId,
-      xChainType: this.xChainType,
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    const walletSelector = this.getXService().walletSelector;
-    await walletSelector.disconnect(this._wallet);
-  }
-
-  public get icon() {
-    return this._wallet.manifest.icon;
-  }
-}